Upgrade ash to 0.37.3+1.3.251 am: 9eedfe518a am: 263119f6f2 am: b0c8db4dff am: 9a1b8ac9c9

Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/ash/+/2691349

Change-Id: I3a0fb5ea2a772e939bee9e104230e71c37c763c3
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

101 files changed, 55344 insertions, 22832 deletions

diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 6e4b9f2..864751e 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,6 @@
 {
   "git": {
-    "sha1": "1b4c82e1d61fa199e135a075bc9f456e6ff47858"
-  }
-}
+    "sha1": "66c0cf42a00d219dc6d7d8b0ca9a112670a54f87"
+  },
+  "path_in_vcs": "ash"
+}
\ No newline at end of file
diff --git a/Android.bp b/Android.bp
index 2158d14..4db0331 100644
--- a/Android.bp
+++ b/Android.bp
@@ -39,21 +39,22 @@ license {
 
 rust_test {
     name: "ash_test_src_lib",
-    // has rustc warnings
     host_supported: true,
     crate_name: "ash",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.33.3+1.2.191",
+    cargo_pkg_version: "0.37.3+1.3.251",
     srcs: ["src/lib.rs"],
     test_suites: ["general-tests"],
     auto_gen_config: true,
     test_options: {
         unit_test: true,
     },
-    edition: "2018",
+    edition: "2021",
     features: [
+        "debug",
         "default",
         "libloading",
+        "loaded",
     ],
     rustlibs: [
         "liblibloading",
@@ -64,13 +65,15 @@ rust_defaults {
     name: "ash_test_defaults",
     crate_name: "ash",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.33.3+1.2.191",
+    cargo_pkg_version: "0.37.3+1.3.251",
     test_suites: ["general-tests"],
     auto_gen_config: true,
-    edition: "2018",
+    edition: "2021",
     features: [
+        "debug",
         "default",
         "libloading",
+        "loaded",
     ],
     rustlibs: [
         "libash_rust",
@@ -81,7 +84,6 @@ rust_defaults {
 rust_test {
     name: "ash_test_tests_constant_size_arrays",
     defaults: ["ash_test_defaults"],
-    // has rustc warnings
     host_supported: true,
     srcs: ["tests/constant_size_arrays.rs"],
     test_options: {
@@ -92,7 +94,6 @@ rust_test {
 rust_test {
     name: "ash_test_tests_display",
     defaults: ["ash_test_defaults"],
-    // has rustc warnings
     host_supported: true,
     srcs: ["tests/display.rs"],
     test_options: {
@@ -103,16 +104,17 @@ rust_test {
 rust_library {
     name: "libash_rust",
     stem: "libash",
-    // has rustc warnings
     host_supported: true,
     crate_name: "ash",
     cargo_env_compat: true,
-    cargo_pkg_version: "0.33.3+1.2.191",
+    cargo_pkg_version: "0.37.3+1.3.251",
     srcs: ["src/lib.rs"],
-    edition: "2018",
+    edition: "2021",
     features: [
+        "debug",
         "default",
         "libloading",
+        "loaded",
     ],
     rustlibs: [
         "liblibloading",
diff --git a/Cargo.toml b/Cargo.toml
index 314b3a6..31a170a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,29 +3,52 @@
 # When uploading crates to the registry Cargo will automatically
 # "normalize" Cargo.toml files for maximal compatibility
 # with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies
+# to registry (e.g., crates.io) dependencies.
 #
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
 
 [package]
-edition = "2018"
+edition = "2021"
+rust-version = "1.59.0"
 name = "ash"
-version = "0.33.3+1.2.191"
-authors = ["maik klein <maikklein@googlemail.com>"]
+version = "0.37.3+1.3.251"
+authors = [
+    "Maik Klein <maikklein@googlemail.com>",
+    "Benjamin Saunders <ben.e.saunders@gmail.com>",
+    "Marijn Suijten <marijn@traverseresearch.nl>",
+]
 description = "Vulkan bindings for Rust"
 documentation = "https://docs.rs/ash"
-readme = "../README.md"
-keywords = ["vulkan", "graphic"]
-license = "MIT"
+readme = "README.md"
+keywords = [
+    "vulkan",
+    "graphic",
+]
+license = "MIT OR Apache-2.0"
 repository = "https://github.com/MaikKlein/ash"
+resolver = "1"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+
 [package.metadata.release]
 no-dev-version = true
+
 [dependencies.libloading]
 version = "0.7"
 optional = true
 
 [features]
-default = ["libloading"]
+debug = []
+default = [
+    "loaded",
+    "debug",
+]
+linked = []
+loaded = ["libloading"]
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 914f217..3587c7f 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,20 +1,35 @@
 [package]
 name = "ash"
-version = "0.33.3+1.2.191"
-authors = ["maik klein <maikklein@googlemail.com>"]
+version = "0.37.3+1.3.251"
+authors = [
+    "Maik Klein <maikklein@googlemail.com>",
+    "Benjamin Saunders <ben.e.saunders@gmail.com>",
+    "Marijn Suijten <marijn@traverseresearch.nl>",
+]
 description = "Vulkan bindings for Rust"
-license = "MIT"
+license = "MIT OR Apache-2.0"
 repository = "https://github.com/MaikKlein/ash"
 readme = "../README.md"
 keywords = ["vulkan", "graphic"]
 documentation = "https://docs.rs/ash"
-edition = "2018"
+edition = "2021"
+rust-version = "1.59.0"
 
 [dependencies]
 libloading = { version = "0.7", optional = true }
 
 [features]
-default = ["libloading"]
+default = ["loaded", "debug"]
+# Link the Vulkan loader at compile time.
+linked = []
+# Support searching for the Vulkan loader manually at runtime.
+loaded = ["libloading"]
+# Whether Vulkan structs should implement Debug.
+debug = []
 
 [package.metadata.release]
 no-dev-version = true
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
diff --git a/METADATA b/METADATA
index 128b51b..502a932 100644
--- a/METADATA
+++ b/METADATA
@@ -1,3 +1,7 @@
+# This project was upgraded with external_updater.
+# Usage: tools/external_updater/updater.sh update rust/crates/ash
+# For more info, check https://cs.android.com/android/platform/superproject/+/main:tools/external_updater/README.md
+
 name: "ash"
 description: "Vulkan bindings for Rust"
 third_party {
@@ -7,13 +11,13 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/ash/ash-0.33.3+1.2.191.crate"
+    value: "https://static.crates.io/crates/ash/ash-0.37.3+1.3.251.crate"
   }
-  version: "0.33.3+1.2.191"
+  version: "0.37.3+1.3.251"
   license_type: NOTICE
   last_upgrade_date {
-    year: 2021
-    month: 9
-    day: 30
+    year: 2023
+    month: 8
+    day: 2
   }
 }
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..513519c
--- /dev/null
+++ b/README.md
@@ -0,0 +1,290 @@
+# Ash
+
+A very lightweight wrapper around Vulkan
+
+[![Crates.io Version](https://img.shields.io/crates/v/ash.svg)](https://crates.io/crates/ash)
+[![Documentation](https://docs.rs/ash/badge.svg)](https://docs.rs/ash)
+[![Build Status](https://github.com/MaikKlein/ash/workflows/CI/badge.svg)](https://github.com/MaikKlein/ash/actions?workflow=CI)
+[![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE-MIT)
+[![LICENSE](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE-APACHE)
+[![Join the chat at https://gitter.im/MaikKlein/ash](https://badges.gitter.im/MaikKlein/ash.svg)](https://gitter.im/MaikKlein/ash?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![MSRV](https://img.shields.io/badge/rustc-1.60.0+-ab6000.svg)](https://blog.rust-lang.org/2022/04/07/Rust-1.60.0.html)
+
+## Overview
+- [x] A true Vulkan API without compromises
+- [x] Convenience features without limiting functionality
+- [x] Additional type safety
+- [x] Device local function pointer loading
+- [x] No validation, everything is **unsafe**
+- [x] Generated from `vk.xml`
+- [x] Support for Vulkan `1.1`, `1.2`, `1.3`
+
+## ⚠️ Semver compatibility warning
+The Vulkan Video bindings are experimental and still seeing breaking changes in their upstream specification, and are only provided by Ash for early adopters. All related functions and types are semver-exempt [^1] (we allow breaking API changes while releasing Ash with non-breaking semver bumps).
+
+[^1]: `generator` complexity makes it so that we cannot easily hide these bindings behind a non-`default` feature flag, and they are widespread across the generated codebase.
+
+## Features
+### Explicit returns with `Result`
+```rust
+// function signature
+pub fn create_instance(&self,
+                       create_info: &vk::InstanceCreateInfo,
+                       allocation_callbacks: Option<&vk::AllocationCallbacks>)
+                       -> Result<Instance, InstanceError> { .. }
+let instance = entry.create_instance(&create_info, None)
+    .expect("Instance creation error");
+```
+
+
+### `Vec<T>` instead of mutable slices
+
+```rust
+pub fn get_swapchain_images(&self,
+                            swapchain: vk::SwapchainKHR)
+                            -> VkResult<Vec<vk::Image>>;
+let present_images = swapchain_loader.get_swapchain_images_khr(swapchain).unwrap();
+```
+*Note*: Functions don't return `Vec<T>` if this would limit the functionality. See `p_next`.
+
+### Slices
+```rust
+pub 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]);
+```
+
+### Strongly typed handles
+
+Each Vulkan handle type is exposed as a newtyped struct for improved type safety. Null handles can be constructed with
+`T::null()`, and handles may be freely converted to and from `u64` with `Handle::from_raw` and `Handle::as_raw` for
+interop with non-Ash Vulkan code.
+
+### Default implementation for all types
+```rust
+// No need to manually set the structure type
+let desc_alloc_info = vk::DescriptorSetAllocateInfo {
+    descriptor_pool: self.pool,
+    descriptor_set_count: self.layouts.len() as u32,
+    p_set_layouts: self.layouts.as_ptr(),
+    ..Default::default()
+};
+```
+### Builder pattern
+
+```rust
+// We lose all lifetime information when we call `.build()`. Be careful!
+let queue_info = [vk::DeviceQueueCreateInfo::builder()
+    .queue_family_index(queue_family_index)
+    .queue_priorities(&priorities)
+    .build()];
+
+// We don't need to call `.build()` here because builders implement `Deref`.
+let device_create_info = vk::DeviceCreateInfo::builder()
+    .queue_create_infos(&queue_info)
+    .enabled_extension_names(&device_extension_names_raw)
+    .enabled_features(&features);
+
+let device: Device = instance
+    .create_device(pdevice, &device_create_info, None)
+    .unwrap();
+```
+
+To not lose this lifetime single items can be "cast" to a slice of length _one_ with `std::slice::from_ref` while still taking advantage of `Deref`:
+
+```rust
+let queue_info = vk::DeviceQueueCreateInfo::builder()
+    .queue_family_index(queue_family_index)
+    .queue_priorities(&priorities);
+
+let device_create_info = vk::DeviceCreateInfo::builder()
+    .queue_create_infos(std::slice::from_ref(&queue_info))
+    ...;
+```
+
+Builders have an explicit lifetime, and are marked as `#[repr(transparent)]`.
+```rust
+#[repr(transparent)]
+pub struct DeviceCreateInfoBuilder<'a> {
+    inner: DeviceCreateInfo,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> DeviceCreateInfoBuilder<'a> {
+    //...
+    pub fn queue_create_infos(
+        mut self,
+        queue_create_infos: &'a [DeviceQueueCreateInfo],
+    ) -> DeviceCreateInfoBuilder<'a> {...}
+    //...
+```
+
+Every reference has to live as long as the builder itself. Builders implement `Deref` targeting their corresponding Vulkan struct, so references to builders can be passed directly
+to Vulkan functions.
+
+Calling `.build()` will **discard** that lifetime because Vulkan structs use raw pointers internally. This should be avoided as much as possible because this can easily lead to dangling pointers. If `.build()` has to be called, it should be called as late as possible. [Lifetimes of temporaries](https://doc.rust-lang.org/reference/expressions.html#temporary-lifetimes) are extended to the enclosing statement, ensuring they are valid for the duration of a Vulkan call occurring in the same statement.
+
+
+### Pointer chains
+
+```rust
+let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder();
+let mut corner =
+    vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder();
+;
+let mut device_create_info = vk::DeviceCreateInfo::builder()
+    .push_next(&mut corner)
+    .push_next(&mut variable_pointers);
+```
+
+Pointer chains in builders differ from raw Vulkan. Instead of chaining every struct manually, you instead use `.push_next` on the struct that you are going to pass into the function. Those structs then get *prepended* into the chain.
+
+`push_next` is also type checked, you can only add valid structs to the chain. Both the structs and the builders can be passed into `push_next`. Only builders for structs that can be passed into functions will implement a `push_next`.
+
+
+### Flags and constants as associated constants
+
+```rust
+// Bitflag
+vk::AccessFlags::COLOR_ATTACHMENT_READ | vk::AccessFlags::COLOR_ATTACHMENT_WRITE
+```
+
+```rust
+// Constant
+vk::PipelineBindPoint::GRAPHICS,
+```
+### Debug/Display for Flags
+
+```rust
+let flag = vk::AccessFlags::COLOR_ATTACHMENT_READ
+        | vk::AccessFlags::COLOR_ATTACHMENT_WRITE;
+println!("Debug: {:?}", flag);
+println!("Display: {}", flag);
+// Prints:
+// Debug: AccessFlags(110000000)
+// Display: COLOR_ATTACHMENT_READ | COLOR_ATTACHMENT_WRITE
+```
+
+### Function pointer loading
+Ash also takes care of loading the function pointers. Function pointers are split into 3 categories.
+
+* Entry: Loads the Vulkan library. Needs to outlive `Instance` and `Device`.
+* Instance: Loads instance level functions. Needs to outlive the `Device`s it has created.
+* Device: Loads device **local** functions.
+
+The loader is just one possible implementation:
+
+* Device level functions are retrieved on a per device basis.
+* Everything is loaded by default, functions that failed to load are initialized to a function that always panics.
+* Do not call Vulkan 1.1 functions if you have created a 1.0 instance. Doing so will result in a panic.
+
+Custom loaders can be implemented.
+
+### Extension loading
+Additionally, every Vulkan extension has to be loaded explicitly. You can find all extensions under [ash::extensions](https://github.com/MaikKlein/ash/tree/master/ash/src/extensions).
+```rust
+use ash::extensions::khr::Swapchain;
+let swapchain_loader = Swapchain::new(&instance, &device);
+let swapchain = swapchain_loader.create_swapchain(&swapchain_create_info).unwrap();
+```
+
+### Raw function pointers
+
+Raw function pointers are available, if something hasn't been exposed yet in the higher level API. Please open an issue if anything is missing.
+
+```rust
+device.fp_v1_0().destroy_device(...);
+```
+
+### Support for extension names
+```rust
+use ash::extensions::{Swapchain, XlibSurface, Surface, DebugReport};
+#[cfg(all(unix, not(target_os = "android")))]
+fn extension_names() -> Vec<*const i8> {
+    vec![
+        Surface::name().as_ptr(),
+        XlibSurface::name().as_ptr(),
+        DebugReport::name().as_ptr()
+    ]
+}
+```
+
+### Implicit handles
+Handles from Instance or Device are passed implicitly.
+```rust
+pub fn create_command_pool(&self,
+                           create_info: &vk::CommandPoolCreateInfo)
+                           -> VkResult<vk::CommandPool>;
+
+let pool = device.create_command_pool(&pool_create_info).unwrap();
+```
+
+### Optional linking
+
+The default `loaded` cargo feature will dynamically load the default Vulkan library for the current platform with `Entry::load`, meaning that the build environment does not have to have Vulkan development packages installed.
+
+If, on the other hand, your application cannot handle Vulkan being missing at runtime, you can instead enable the `linked` feature, which will link your binary with the Vulkan loader directly and expose the infallible `Entry::linked`.
+
+## Example
+You can find the examples [here](https://github.com/MaikKlein/ash/tree/master/examples).
+All examples currently require: the LunarG Validation layers and a Vulkan library that is visible in your `PATH`. An easy way to get started is to use the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/)
+#### Windows
+Make sure that you have a Vulkan ready driver and install the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/).
+#### Linux
+Make sure that you have a Vulkan ready driver and install the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/). You also have to add the library and layers to your path. Have a look at my [post](http://askubuntu.com/a/803110/77183) if you are unsure how to do that.
+#### macOS
+Install the [LunarG Vulkan SDK](https://lunarg.com/vulkan-sdk/). The installer puts the SDK in `$HOME/VulkanSDK/<version>` by default. You will need to set the following environment variables when running cargo:
+```sh
+VULKAN_SDK=$HOME/VulkanSDK/<version>/macOS \
+DYLD_FALLBACK_LIBRARY_PATH=$VULKAN_SDK/lib \
+VK_ICD_FILENAMES=$VULKAN_SDK/share/vulkan/icd.d/MoltenVK_icd.json \
+VK_LAYER_PATH=$VULKAN_SDK/share/vulkan/explicit_layer.d \
+cargo run ...
+```
+
+### [Triangle](https://github.com/MaikKlein/ash/blob/master/examples/src/bin/triangle.rs)
+Displays a triangle with vertex colors.
+```
+cd examples
+cargo run --bin triangle
+```
+
+![screenshot](http://i.imgur.com/PQZcL6w.jpg)
+
+### [Texture](https://github.com/MaikKlein/ash/blob/master/examples/src/bin/texture.rs)
+Displays a texture on a quad.
+```
+cd examples
+cargo run --bin texture
+```
+![texture](http://i.imgur.com/trow00H.png)
+
+## Useful resources
+
+### Examples
+
+* [vulkan-tutorial-rust](https://github.com/Usami-Renko/vulkan-tutorial-rust) - A port of [vulkan-tutorial.com](https://vulkan-tutorial.com).
+* [ash-sample-progression](https://github.com/bzm3r/ash-sample-progression) - A port of the LunarG examples.
+* [ash-nv-rt](https://github.com/gwihlidal/ash-nv-rt) A raytracing example for ash.
+
+### Utility libraries
+* [vk-sync](https://github.com/gwihlidal/vk-sync-rs) - Simplified Vulkan synchronization logic, written in rust.
+* [vk-mem-rs](https://github.com/gwihlidal/vk-mem-rs) - This crate provides an FFI layer and idiomatic rust wrappers for the excellent AMD Vulkan Memory Allocator (VMA) C/C++ library.
+* [gpu-allocator](https://github.com/Traverse-Research/gpu-allocator) - Memory allocator written in pure Rust for GPU memory in Vulkan and in the future DirectX 12
+* [lahar](https://github.com/Ralith/lahar) - Tools for asynchronously uploading data to a Vulkan device.
+
+### Libraries that use ash
+* [gfx-rs](https://github.com/gfx-rs/gfx) - gfx-rs is a low-level, cross-platform graphics abstraction library in Rust.
+
+## A thanks to
+
+* [Api with no secrets](https://software.intel.com/en-us/articles/api-without-secrets-introduction-to-vulkan-part-1)
+* [Vulkan tutorial](http://jhenriques.net/development.html)
+* [Vulkan examples](https://github.com/SaschaWillems/Vulkan)
+* [Vulkan tutorial](https://vulkan-tutorial.com/)
+* [Vulkano](https://github.com/vulkano-rs/vulkano)
+* [vk-rs](https://github.com/Osspial/vk-rs)
diff --git a/build.rs b/build.rs
new file mode 100644
index 0000000..7ccdbc4
--- /dev/null
+++ b/build.rs
@@ -0,0 +1,24 @@
+fn main() {
+    #[cfg(feature = "linked")]
+    {
+        use std::env;
+
+        let target_family = env::var("CARGO_CFG_TARGET_FAMILY").unwrap();
+        let target_pointer_width = env::var("CARGO_CFG_TARGET_POINTER_WIDTH").unwrap();
+
+        println!("cargo:rerun-if-env-changed=VULKAN_SDK");
+        if let Ok(var) = env::var("VULKAN_SDK") {
+            let suffix = match (&*target_family, &*target_pointer_width) {
+                ("windows", "32") => "Lib32",
+                ("windows", "64") => "Lib",
+                _ => "lib",
+            };
+            println!("cargo:rustc-link-search={var}/{suffix}");
+        }
+        let lib = match &*target_family {
+            "windows" => "vulkan-1",
+            _ => "vulkan",
+        };
+        println!("cargo:rustc-link-lib={lib}");
+    }
+}
diff --git a/src/device.rs b/src/device.rs
index 87c53c7..cf0fca7 100644
--- a/src/device.rs
+++ b/src/device.rs
@@ -6,7 +6,7 @@ use std::mem;
 use std::os::raw::c_void;
 use std::ptr;
 
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDevice.html>"]
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevice.html>
 #[derive(Clone)]
 pub struct Device {
     pub(crate) handle: vk::Device,
@@ -14,36 +14,532 @@ pub struct Device {
     pub(crate) device_fn_1_0: vk::DeviceFnV1_0,
     pub(crate) device_fn_1_1: vk::DeviceFnV1_1,
     pub(crate) device_fn_1_2: vk::DeviceFnV1_2,
+    pub(crate) device_fn_1_3: vk::DeviceFnV1_3,
 }
 
 impl Device {
     pub unsafe fn load(instance_fn: &vk::InstanceFnV1_0, device: vk::Device) -> Self {
         let load_fn = |name: &std::ffi::CStr| {
-            mem::transmute(instance_fn.get_device_proc_addr(device, name.as_ptr()))
+            mem::transmute((instance_fn.get_device_proc_addr)(device, name.as_ptr()))
         };
 
-        Device {
+        Self {
             handle: device,
 
             device_fn_1_0: vk::DeviceFnV1_0::load(load_fn),
             device_fn_1_1: vk::DeviceFnV1_1::load(load_fn),
             device_fn_1_2: vk::DeviceFnV1_2::load(load_fn),
+            device_fn_1_3: vk::DeviceFnV1_3::load(load_fn),
         }
     }
 
+    #[inline]
     pub fn handle(&self) -> vk::Device {
         self.handle
     }
 }
 
+/// Vulkan core 1.3
+#[allow(non_camel_case_types)]
+impl Device {
+    #[inline]
+    pub fn fp_v1_3(&self) -> &vk::DeviceFnV1_3 {
+        &self.device_fn_1_3
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreatePrivateDataSlot.html>
+    #[inline]
+    pub unsafe fn create_private_data_slot(
+        &self,
+        create_info: &vk::PrivateDataSlotCreateInfo,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::PrivateDataSlot> {
+        let mut private_data_slot = mem::zeroed();
+        (self.device_fn_1_3.create_private_data_slot)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut private_data_slot,
+        )
+        .result_with_success(private_data_slot)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyPrivateDataSlot.html>
+    #[inline]
+    pub unsafe fn destroy_private_data_slot(
+        &self,
+        private_data_slot: vk::PrivateDataSlot,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) {
+        (self.device_fn_1_3.destroy_private_data_slot)(
+            self.handle,
+            private_data_slot,
+            allocation_callbacks.as_raw_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetPrivateData.html>
+    #[inline]
+    pub unsafe fn set_private_data<T: vk::Handle>(
+        &self,
+        object: T,
+        private_data_slot: vk::PrivateDataSlot,
+        data: u64,
+    ) -> VkResult<()> {
+        (self.device_fn_1_3.set_private_data)(
+            self.handle,
+            T::TYPE,
+            object.as_raw(),
+            private_data_slot,
+            data,
+        )
+        .result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPrivateData.html>
+    #[inline]
+    pub unsafe fn get_private_data<T: vk::Handle>(
+        &self,
+        object: T,
+        private_data_slot: vk::PrivateDataSlot,
+    ) -> u64 {
+        let mut data = mem::zeroed();
+        (self.device_fn_1_3.get_private_data)(
+            self.handle,
+            T::TYPE,
+            object.as_raw(),
+            private_data_slot,
+            &mut data,
+        );
+        data
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdPipelineBarrier2.html>
+    #[inline]
+    pub unsafe fn cmd_pipeline_barrier2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        dependency_info: &vk::DependencyInfo,
+    ) {
+        (self.device_fn_1_3.cmd_pipeline_barrier2)(command_buffer, dependency_info)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdResetEvent2.html>
+    #[inline]
+    pub unsafe fn cmd_reset_event2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        event: vk::Event,
+        stage_mask: vk::PipelineStageFlags2,
+    ) {
+        (self.device_fn_1_3.cmd_reset_event2)(command_buffer, event, stage_mask)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetEvent2.html>
+    #[inline]
+    pub unsafe fn cmd_set_event2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        event: vk::Event,
+        dependency_info: &vk::DependencyInfo,
+    ) {
+        (self.device_fn_1_3.cmd_set_event2)(command_buffer, event, dependency_info)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWaitEvents2.html>
+    #[inline]
+    pub unsafe fn cmd_wait_events2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        events: &[vk::Event],
+        dependency_infos: &[vk::DependencyInfo],
+    ) {
+        assert_eq!(events.len(), dependency_infos.len());
+        (self.device_fn_1_3.cmd_wait_events2)(
+            command_buffer,
+            events.len() as u32,
+            events.as_ptr(),
+            dependency_infos.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWriteTimestamp2.html>
+    #[inline]
+    pub unsafe fn cmd_write_timestamp2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        stage: vk::PipelineStageFlags2,
+        query_pool: vk::QueryPool,
+        query: u32,
+    ) {
+        (self.device_fn_1_3.cmd_write_timestamp2)(command_buffer, stage, query_pool, query)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueSubmit2.html>
+    #[inline]
+    pub unsafe fn queue_submit2(
+        &self,
+        queue: vk::Queue,
+        submits: &[vk::SubmitInfo2],
+        fence: vk::Fence,
+    ) -> VkResult<()> {
+        (self.device_fn_1_3.queue_submit2)(queue, submits.len() as u32, submits.as_ptr(), fence)
+            .result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyBuffer2.html>
+    #[inline]
+    pub unsafe fn cmd_copy_buffer2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        copy_buffer_info: &vk::CopyBufferInfo2,
+    ) {
+        (self.device_fn_1_3.cmd_copy_buffer2)(command_buffer, copy_buffer_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyImage2.html>
+    #[inline]
+    pub unsafe fn cmd_copy_image2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        copy_image_info: &vk::CopyImageInfo2,
+    ) {
+        (self.device_fn_1_3.cmd_copy_image2)(command_buffer, copy_image_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyBufferToImage2.html>
+    #[inline]
+    pub unsafe fn cmd_copy_buffer_to_image2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2,
+    ) {
+        (self.device_fn_1_3.cmd_copy_buffer_to_image2)(command_buffer, copy_buffer_to_image_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyImageToBuffer2.html>
+    #[inline]
+    pub unsafe fn cmd_copy_image_to_buffer2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2,
+    ) {
+        (self.device_fn_1_3.cmd_copy_image_to_buffer2)(command_buffer, copy_image_to_buffer_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBlitImage2.html>
+    #[inline]
+    pub unsafe fn cmd_blit_image2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        blit_image_info: &vk::BlitImageInfo2,
+    ) {
+        (self.device_fn_1_3.cmd_blit_image2)(command_buffer, blit_image_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdResolveImage2.html>
+    #[inline]
+    pub unsafe fn cmd_resolve_image2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        resolve_image_info: &vk::ResolveImageInfo2,
+    ) {
+        (self.device_fn_1_3.cmd_resolve_image2)(command_buffer, resolve_image_info)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginRendering.html>
+    #[inline]
+    pub unsafe fn cmd_begin_rendering(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        rendering_info: &vk::RenderingInfo,
+    ) {
+        (self.device_fn_1_3.cmd_begin_rendering)(command_buffer, rendering_info)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndRendering.html>
+    #[inline]
+    pub unsafe fn cmd_end_rendering(&self, command_buffer: vk::CommandBuffer) {
+        (self.device_fn_1_3.cmd_end_rendering)(command_buffer)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCullMode.html>
+    #[inline]
+    pub unsafe fn cmd_set_cull_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        cull_mode: vk::CullModeFlags,
+    ) {
+        (self.device_fn_1_3.cmd_set_cull_mode)(command_buffer, cull_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetFrontFace.html>
+    #[inline]
+    pub unsafe fn cmd_set_front_face(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        front_face: vk::FrontFace,
+    ) {
+        (self.device_fn_1_3.cmd_set_front_face)(command_buffer, front_face)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveTopology.html>
+    #[inline]
+    pub unsafe fn cmd_set_primitive_topology(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        primitive_topology: vk::PrimitiveTopology,
+    ) {
+        (self.device_fn_1_3.cmd_set_primitive_topology)(command_buffer, primitive_topology)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportWithCount.html>
+    #[inline]
+    pub unsafe fn cmd_set_viewport_with_count(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        viewports: &[vk::Viewport],
+    ) {
+        (self.device_fn_1_3.cmd_set_viewport_with_count)(
+            command_buffer,
+            viewports.len() as u32,
+            viewports.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetScissorWithCount.html>
+    #[inline]
+    pub unsafe fn cmd_set_scissor_with_count(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        scissors: &[vk::Rect2D],
+    ) {
+        (self.device_fn_1_3.cmd_set_scissor_with_count)(
+            command_buffer,
+            scissors.len() as u32,
+            scissors.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindVertexBuffers2.html>
+    #[inline]
+    pub unsafe fn cmd_bind_vertex_buffers2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_binding: u32,
+        buffers: &[vk::Buffer],
+        offsets: &[vk::DeviceSize],
+        sizes: Option<&[vk::DeviceSize]>,
+        strides: Option<&[vk::DeviceSize]>,
+    ) {
+        assert_eq!(offsets.len(), buffers.len());
+        let p_sizes = if let Some(sizes) = sizes {
+            assert_eq!(sizes.len(), buffers.len());
+            sizes.as_ptr()
+        } else {
+            ptr::null()
+        };
+        let p_strides = if let Some(strides) = strides {
+            assert_eq!(strides.len(), buffers.len());
+            strides.as_ptr()
+        } else {
+            ptr::null()
+        };
+        (self.device_fn_1_3.cmd_bind_vertex_buffers2)(
+            command_buffer,
+            first_binding,
+            buffers.len() as u32,
+            buffers.as_ptr(),
+            offsets.as_ptr(),
+            p_sizes,
+            p_strides,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthTestEnable.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_test_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_test_enable: bool,
+    ) {
+        (self.device_fn_1_3.cmd_set_depth_test_enable)(command_buffer, depth_test_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthWriteEnable.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_write_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_write_enable: bool,
+    ) {
+        (self.device_fn_1_3.cmd_set_depth_write_enable)(command_buffer, depth_write_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthCompareOp.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_compare_op(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_compare_op: vk::CompareOp,
+    ) {
+        (self.device_fn_1_3.cmd_set_depth_compare_op)(command_buffer, depth_compare_op)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBoundsTestEnable.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_bounds_test_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_bounds_test_enable: bool,
+    ) {
+        (self.device_fn_1_3.cmd_set_depth_bounds_test_enable)(
+            command_buffer,
+            depth_bounds_test_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilTestEnable.html>
+    #[inline]
+    pub unsafe fn cmd_set_stencil_test_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        stencil_test_enable: bool,
+    ) {
+        (self.device_fn_1_3.cmd_set_stencil_test_enable)(command_buffer, stencil_test_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/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,
+    ) {
+        (self.device_fn_1_3.cmd_set_stencil_op)(
+            command_buffer,
+            face_mask,
+            fail_op,
+            pass_op,
+            depth_fail_op,
+            compare_op,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizerDiscardEnable.html>
+    #[inline]
+    pub unsafe fn cmd_set_rasterizer_discard_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        rasterizer_discard_enable: bool,
+    ) {
+        (self.device_fn_1_3.cmd_set_rasterizer_discard_enable)(
+            command_buffer,
+            rasterizer_discard_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBiasEnable.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_bias_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_bias_enable: bool,
+    ) {
+        (self.device_fn_1_3.cmd_set_depth_bias_enable)(command_buffer, depth_bias_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveRestartEnable.html>
+    #[inline]
+    pub unsafe fn cmd_set_primitive_restart_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        primitive_restart_enable: bool,
+    ) {
+        (self.device_fn_1_3.cmd_set_primitive_restart_enable)(
+            command_buffer,
+            primitive_restart_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceBufferMemoryRequirements.html>
+    #[inline]
+    pub unsafe fn get_device_buffer_memory_requirements(
+        &self,
+        memory_requirements: &vk::DeviceBufferMemoryRequirements,
+        out: &mut vk::MemoryRequirements2,
+    ) {
+        (self.device_fn_1_3.get_device_buffer_memory_requirements)(
+            self.handle,
+            memory_requirements,
+            out,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceImageMemoryRequirements.html>
+    #[inline]
+    pub unsafe fn get_device_image_memory_requirements(
+        &self,
+        memory_requirements: &vk::DeviceImageMemoryRequirements,
+        out: &mut vk::MemoryRequirements2,
+    ) {
+        (self.device_fn_1_3.get_device_image_memory_requirements)(
+            self.handle,
+            memory_requirements,
+            out,
+        )
+    }
+
+    /// Retrieve the number of elements to pass to [`get_device_image_sparse_memory_requirements()`][Self::get_device_image_sparse_memory_requirements()]
+    #[inline]
+    pub unsafe fn get_device_image_sparse_memory_requirements_len(
+        &self,
+        memory_requirements: &vk::DeviceImageMemoryRequirements,
+    ) -> usize {
+        let mut count = 0;
+        (self
+            .device_fn_1_3
+            .get_device_image_sparse_memory_requirements)(
+            self.handle,
+            memory_requirements,
+            &mut count,
+            std::ptr::null_mut(),
+        );
+        count as usize
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceImageSparseMemoryRequirements.html>
+    ///
+    /// Call [`get_device_image_sparse_memory_requirements_len()`][Self::get_device_image_sparse_memory_requirements_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn get_device_image_sparse_memory_requirements(
+        &self,
+        memory_requirements: &vk::DeviceImageMemoryRequirements,
+        out: &mut [vk::SparseImageMemoryRequirements2],
+    ) {
+        let mut count = out.len() as u32;
+        (self
+            .device_fn_1_3
+            .get_device_image_sparse_memory_requirements)(
+            self.handle,
+            memory_requirements,
+            &mut count,
+            out.as_mut_ptr(),
+        );
+        assert_eq!(count as usize, out.len());
+    }
+}
+
 /// Vulkan core 1.2
 #[allow(non_camel_case_types)]
 impl Device {
+    #[inline]
     pub fn fp_v1_2(&self) -> &vk::DeviceFnV1_2 {
         &self.device_fn_1_2
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirectCount.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawIndirectCount.html>
+    #[inline]
     pub unsafe fn cmd_draw_indirect_count(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -54,7 +550,7 @@ impl Device {
         max_draw_count: u32,
         stride: u32,
     ) {
-        self.device_fn_1_2.cmd_draw_indirect_count(
+        (self.device_fn_1_2.cmd_draw_indirect_count)(
             command_buffer,
             buffer,
             offset,
@@ -65,7 +561,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirectCount.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawIndexedIndirectCount.html>
+    #[inline]
     pub unsafe fn cmd_draw_indexed_indirect_count(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -76,7 +573,7 @@ impl Device {
         max_draw_count: u32,
         stride: u32,
     ) {
-        self.device_fn_1_2.cmd_draw_indexed_indirect_count(
+        (self.device_fn_1_2.cmd_draw_indexed_indirect_count)(
             command_buffer,
             buffer,
             offset,
@@ -87,151 +584,164 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateRenderPass2.html>
+    #[inline]
     pub unsafe fn create_render_pass2(
         &self,
         create_info: &vk::RenderPassCreateInfo2,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::RenderPass> {
         let mut renderpass = mem::zeroed();
-        self.device_fn_1_2
-            .create_render_pass2(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut renderpass,
-            )
-            .result_with_success(renderpass)
+        (self.device_fn_1_2.create_render_pass2)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut renderpass,
+        )
+        .result_with_success(renderpass)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginRenderPass2.html>
+    #[inline]
     pub unsafe fn cmd_begin_render_pass2(
         &self,
         command_buffer: vk::CommandBuffer,
         render_pass_begin_info: &vk::RenderPassBeginInfo,
         subpass_begin_info: &vk::SubpassBeginInfo,
     ) {
-        self.device_fn_1_2.cmd_begin_render_pass2(
+        (self.device_fn_1_2.cmd_begin_render_pass2)(
             command_buffer,
             render_pass_begin_info,
             subpass_begin_info,
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdNextSubpass2.html>
+    #[inline]
     pub unsafe fn cmd_next_subpass2(
         &self,
         command_buffer: vk::CommandBuffer,
         subpass_begin_info: &vk::SubpassBeginInfo,
         subpass_end_info: &vk::SubpassEndInfo,
     ) {
-        self.device_fn_1_2
-            .cmd_next_subpass2(command_buffer, subpass_begin_info, subpass_end_info);
+        (self.device_fn_1_2.cmd_next_subpass2)(
+            command_buffer,
+            subpass_begin_info,
+            subpass_end_info,
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndRenderPass2.html>
+    #[inline]
     pub unsafe fn cmd_end_render_pass2(
         &self,
         command_buffer: vk::CommandBuffer,
         subpass_end_info: &vk::SubpassEndInfo,
     ) {
-        self.device_fn_1_2
-            .cmd_end_render_pass2(command_buffer, subpass_end_info);
+        (self.device_fn_1_2.cmd_end_render_pass2)(command_buffer, subpass_end_info);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetQueryPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkResetQueryPool.html>
+    #[inline]
     pub unsafe fn reset_query_pool(
         &self,
         query_pool: vk::QueryPool,
         first_query: u32,
         query_count: u32,
     ) {
-        self.device_fn_1_2
-            .reset_query_pool(self.handle(), query_pool, first_query, query_count);
+        (self.device_fn_1_2.reset_query_pool)(self.handle(), query_pool, first_query, query_count);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreCounterValue.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSemaphoreCounterValue.html>
+    #[inline]
     pub unsafe fn get_semaphore_counter_value(&self, semaphore: vk::Semaphore) -> VkResult<u64> {
         let mut value = 0;
-        self.device_fn_1_2
-            .get_semaphore_counter_value(self.handle(), semaphore, &mut value)
+        (self.device_fn_1_2.get_semaphore_counter_value)(self.handle(), semaphore, &mut value)
             .result_with_success(value)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitSemaphores.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkWaitSemaphores.html>
+    #[inline]
     pub unsafe fn wait_semaphores(
         &self,
         wait_info: &vk::SemaphoreWaitInfo,
         timeout: u64,
     ) -> VkResult<()> {
-        self.device_fn_1_2
-            .wait_semaphores(self.handle(), wait_info, timeout)
-            .into()
+        (self.device_fn_1_2.wait_semaphores)(self.handle(), wait_info, timeout).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSignalSemaphore.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSignalSemaphore.html>
+    #[inline]
     pub unsafe fn signal_semaphore(&self, signal_info: &vk::SemaphoreSignalInfo) -> VkResult<()> {
-        self.device_fn_1_2
-            .signal_semaphore(self.handle(), signal_info)
-            .into()
+        (self.device_fn_1_2.signal_semaphore)(self.handle(), signal_info).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferDeviceAddress.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferDeviceAddress.html>
+    #[inline]
     pub unsafe fn get_buffer_device_address(
         &self,
         info: &vk::BufferDeviceAddressInfo,
     ) -> vk::DeviceAddress {
-        self.device_fn_1_2
-            .get_buffer_device_address(self.handle(), info)
+        (self.device_fn_1_2.get_buffer_device_address)(self.handle(), info)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferOpaqueCaptureAddress.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferOpaqueCaptureAddress.html>
+    #[inline]
     pub unsafe fn get_buffer_opaque_capture_address(
         &self,
         info: &vk::BufferDeviceAddressInfo,
     ) -> u64 {
-        self.device_fn_1_2
-            .get_buffer_opaque_capture_address(self.handle(), info)
+        (self.device_fn_1_2.get_buffer_opaque_capture_address)(self.handle(), info)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html>
+    #[inline]
     pub unsafe fn get_device_memory_opaque_capture_address(
         &self,
         info: &vk::DeviceMemoryOpaqueCaptureAddressInfo,
     ) -> u64 {
-        self.device_fn_1_2
-            .get_device_memory_opaque_capture_address(self.handle(), info)
+        (self.device_fn_1_2.get_device_memory_opaque_capture_address)(self.handle(), info)
     }
 }
 
 /// Vulkan core 1.1
 #[allow(non_camel_case_types)]
 impl Device {
+    #[inline]
     pub fn fp_v1_1(&self) -> &vk::DeviceFnV1_1 {
         &self.device_fn_1_1
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindBufferMemory2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBindBufferMemory2.html>
+    #[inline]
     pub unsafe fn bind_buffer_memory2(
         &self,
         bind_infos: &[vk::BindBufferMemoryInfo],
     ) -> VkResult<()> {
-        self.device_fn_1_1
-            .bind_buffer_memory2(self.handle(), bind_infos.len() as _, bind_infos.as_ptr())
-            .into()
+        (self.device_fn_1_1.bind_buffer_memory2)(
+            self.handle(),
+            bind_infos.len() as _,
+            bind_infos.as_ptr(),
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindImageMemory2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBindImageMemory2.html>
+    #[inline]
     pub unsafe fn bind_image_memory2(
         &self,
         bind_infos: &[vk::BindImageMemoryInfo],
     ) -> VkResult<()> {
-        self.device_fn_1_1
-            .bind_image_memory2(self.handle(), bind_infos.len() as _, bind_infos.as_ptr())
-            .into()
+        (self.device_fn_1_1.bind_image_memory2)(
+            self.handle(),
+            bind_infos.len() as _,
+            bind_infos.as_ptr(),
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupPeerMemoryFeatures.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupPeerMemoryFeatures.html>
+    #[inline]
     pub unsafe fn get_device_group_peer_memory_features(
         &self,
         heap_index: u32,
@@ -239,7 +749,7 @@ impl Device {
         remote_device_index: u32,
     ) -> vk::PeerMemoryFeatureFlags {
         let mut peer_memory_features = mem::zeroed();
-        self.device_fn_1_1.get_device_group_peer_memory_features(
+        (self.device_fn_1_1.get_device_group_peer_memory_features)(
             self.handle(),
             heap_index,
             local_device_index,
@@ -249,13 +759,14 @@ impl Device {
         peer_memory_features
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDeviceMask.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDeviceMask.html>
+    #[inline]
     pub unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: u32) {
-        self.device_fn_1_1
-            .cmd_set_device_mask(command_buffer, device_mask);
+        (self.device_fn_1_1.cmd_set_device_mask)(command_buffer, device_mask);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatchBase.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDispatchBase.html>
+    #[inline]
     pub unsafe fn cmd_dispatch_base(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -266,7 +777,7 @@ impl Device {
         group_count_y: u32,
         group_count_z: u32,
     ) {
-        self.device_fn_1_1.cmd_dispatch_base(
+        (self.device_fn_1_1.cmd_dispatch_base)(
             command_buffer,
             base_group_x,
             base_group_y,
@@ -277,32 +788,34 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageMemoryRequirements2.html>
+    #[inline]
     pub unsafe fn get_image_memory_requirements2(
         &self,
         info: &vk::ImageMemoryRequirementsInfo2,
         out: &mut vk::MemoryRequirements2,
     ) {
-        self.device_fn_1_1
-            .get_image_memory_requirements2(self.handle(), info, out);
+        (self.device_fn_1_1.get_image_memory_requirements2)(self.handle(), info, out);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferMemoryRequirements2.html>
+    #[inline]
     pub unsafe fn get_buffer_memory_requirements2(
         &self,
         info: &vk::BufferMemoryRequirementsInfo2,
         out: &mut vk::MemoryRequirements2,
     ) {
-        self.device_fn_1_1
-            .get_buffer_memory_requirements2(self.handle(), info, out);
+        (self.device_fn_1_1.get_buffer_memory_requirements2)(self.handle(), info, out);
     }
 
+    /// Retrieve the number of elements to pass to [`get_image_sparse_memory_requirements2()`][Self::get_image_sparse_memory_requirements2()]
+    #[inline]
     pub unsafe fn get_image_sparse_memory_requirements2_len(
         &self,
         info: &vk::ImageSparseMemoryRequirementsInfo2,
     ) -> usize {
         let mut count = 0;
-        self.device_fn_1_1.get_image_sparse_memory_requirements2(
+        (self.device_fn_1_1.get_image_sparse_memory_requirements2)(
             self.handle(),
             info,
             &mut count,
@@ -311,99 +824,115 @@ impl Device {
         count as usize
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageSparseMemoryRequirements2.html>
+    ///
+    /// Call [`get_image_sparse_memory_requirements2_len()`][Self::get_image_sparse_memory_requirements2_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
     pub unsafe fn get_image_sparse_memory_requirements2(
         &self,
         info: &vk::ImageSparseMemoryRequirementsInfo2,
         out: &mut [vk::SparseImageMemoryRequirements2],
     ) {
         let mut count = out.len() as u32;
-        self.device_fn_1_1.get_image_sparse_memory_requirements2(
+        (self.device_fn_1_1.get_image_sparse_memory_requirements2)(
             self.handle(),
             info,
             &mut count,
             out.as_mut_ptr(),
         );
+        assert_eq!(count as usize, out.len());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkTrimCommandPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkTrimCommandPool.html>
+    #[inline]
     pub unsafe fn trim_command_pool(
         &self,
         command_pool: vk::CommandPool,
         flags: vk::CommandPoolTrimFlags,
     ) {
-        self.device_fn_1_1
-            .trim_command_pool(self.handle(), command_pool, flags);
+        (self.device_fn_1_1.trim_command_pool)(self.handle(), command_pool, flags);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSamplerYcbcrConversion.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceQueue2.html>
+    #[inline]
+    pub unsafe fn get_device_queue2(&self, queue_info: &vk::DeviceQueueInfo2) -> vk::Queue {
+        let mut queue = mem::zeroed();
+        (self.device_fn_1_1.get_device_queue2)(self.handle(), queue_info, &mut queue);
+        queue
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateSamplerYcbcrConversion.html>
+    #[inline]
     pub unsafe fn create_sampler_ycbcr_conversion(
         &self,
         create_info: &vk::SamplerYcbcrConversionCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SamplerYcbcrConversion> {
         let mut ycbcr_conversion = mem::zeroed();
-        self.device_fn_1_1
-            .create_sampler_ycbcr_conversion(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut ycbcr_conversion,
-            )
-            .result_with_success(ycbcr_conversion)
+        (self.device_fn_1_1.create_sampler_ycbcr_conversion)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut ycbcr_conversion,
+        )
+        .result_with_success(ycbcr_conversion)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySamplerYcbcrConversion.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroySamplerYcbcrConversion.html>
+    #[inline]
     pub unsafe fn destroy_sampler_ycbcr_conversion(
         &self,
         ycbcr_conversion: vk::SamplerYcbcrConversion,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_1.destroy_sampler_ycbcr_conversion(
+        (self.device_fn_1_1.destroy_sampler_ycbcr_conversion)(
             self.handle(),
             ycbcr_conversion,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorUpdateTemplate.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDescriptorUpdateTemplate.html>
+    #[inline]
     pub unsafe fn create_descriptor_update_template(
         &self,
         create_info: &vk::DescriptorUpdateTemplateCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DescriptorUpdateTemplate> {
         let mut descriptor_update_template = mem::zeroed();
-        self.device_fn_1_1
-            .create_descriptor_update_template(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut descriptor_update_template,
-            )
-            .result_with_success(descriptor_update_template)
+        (self.device_fn_1_1.create_descriptor_update_template)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut descriptor_update_template,
+        )
+        .result_with_success(descriptor_update_template)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorUpdateTemplate.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDescriptorUpdateTemplate.html>
+    #[inline]
     pub unsafe fn destroy_descriptor_update_template(
         &self,
         descriptor_update_template: vk::DescriptorUpdateTemplate,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_1.destroy_descriptor_update_template(
+        (self.device_fn_1_1.destroy_descriptor_update_template)(
             self.handle(),
             descriptor_update_template,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateDescriptorSetWithTemplate.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkUpdateDescriptorSetWithTemplate.html>
+    #[inline]
     pub unsafe fn update_descriptor_set_with_template(
         &self,
         descriptor_set: vk::DescriptorSet,
         descriptor_update_template: vk::DescriptorUpdateTemplate,
         data: *const c_void,
     ) {
-        self.device_fn_1_1.update_descriptor_set_with_template(
+        (self.device_fn_1_1.update_descriptor_set_with_template)(
             self.handle(),
             descriptor_set,
             descriptor_update_template,
@@ -411,60 +940,63 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDescriptorSetLayoutSupport.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDescriptorSetLayoutSupport.html>
+    #[inline]
     pub unsafe fn get_descriptor_set_layout_support(
         &self,
         create_info: &vk::DescriptorSetLayoutCreateInfo,
         out: &mut vk::DescriptorSetLayoutSupport,
     ) {
-        self.device_fn_1_1
-            .get_descriptor_set_layout_support(self.handle(), create_info, out);
+        (self.device_fn_1_1.get_descriptor_set_layout_support)(self.handle(), create_info, out);
     }
 }
 
 /// Vulkan core 1.0
 #[allow(non_camel_case_types)]
 impl Device {
+    #[inline]
     pub fn fp_v1_0(&self) -> &vk::DeviceFnV1_0 {
         &self.device_fn_1_0
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDevice.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDevice.html>
+    #[inline]
     pub unsafe fn destroy_device(&self, allocation_callbacks: Option<&vk::AllocationCallbacks>) {
-        self.device_fn_1_0
-            .destroy_device(self.handle(), allocation_callbacks.as_raw_ptr());
+        (self.device_fn_1_0.destroy_device)(self.handle(), allocation_callbacks.as_raw_ptr());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySampler.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroySampler.html>
+    #[inline]
     pub unsafe fn destroy_sampler(
         &self,
         sampler: vk::Sampler,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_sampler(
+        (self.device_fn_1_0.destroy_sampler)(
             self.handle(),
             sampler,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeMemory.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkFreeMemory.html>
+    #[inline]
     pub unsafe fn free_memory(
         &self,
         memory: vk::DeviceMemory,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0
-            .free_memory(self.handle(), memory, allocation_callbacks.as_raw_ptr());
+        (self.device_fn_1_0.free_memory)(self.handle(), memory, allocation_callbacks.as_raw_ptr());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeCommandBuffers.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkFreeCommandBuffers.html>
+    #[inline]
     pub unsafe fn free_command_buffers(
         &self,
         command_pool: vk::CommandPool,
         command_buffers: &[vk::CommandBuffer],
     ) {
-        self.device_fn_1_0.free_command_buffers(
+        (self.device_fn_1_0.free_command_buffers)(
             self.handle(),
             command_pool,
             command_buffers.len() as u32,
@@ -472,28 +1004,29 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateEvent.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateEvent.html>
+    #[inline]
     pub unsafe fn create_event(
         &self,
         create_info: &vk::EventCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::Event> {
         let mut event = mem::zeroed();
-        self.device_fn_1_0
-            .create_event(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut event,
-            )
-            .result_with_success(event)
+        (self.device_fn_1_0.create_event)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut event,
+        )
+        .result_with_success(event)
     }
 
     /// Returns [`true`] if the event was set, and [`false`] if the event was reset, otherwise it will
     /// return the error code.
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetEventStatus.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetEventStatus.html>
+    #[inline]
     pub unsafe fn get_event_status(&self, event: vk::Event) -> VkResult<bool> {
-        let err_code = self.device_fn_1_0.get_event_status(self.handle(), event);
+        let err_code = (self.device_fn_1_0.get_event_status)(self.handle(), event);
         match err_code {
             vk::Result::EVENT_SET => Ok(true),
             vk::Result::EVENT_RESET => Ok(false),
@@ -501,37 +1034,40 @@ impl Device {
         }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetEvent.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetEvent.html>
+    #[inline]
     pub unsafe fn set_event(&self, event: vk::Event) -> VkResult<()> {
-        self.device_fn_1_0.set_event(self.handle(), event).into()
+        (self.device_fn_1_0.set_event)(self.handle(), event).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetEvent.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkResetEvent.html>
+    #[inline]
     pub unsafe fn reset_event(&self, event: vk::Event) -> VkResult<()> {
-        self.device_fn_1_0.reset_event(self.handle(), event).into()
+        (self.device_fn_1_0.reset_event)(self.handle(), event).result()
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetEvent.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetEvent.html>
+    #[inline]
     pub unsafe fn cmd_set_event(
         &self,
         command_buffer: vk::CommandBuffer,
         event: vk::Event,
         stage_mask: vk::PipelineStageFlags,
     ) {
-        self.device_fn_1_0
-            .cmd_set_event(command_buffer, event, stage_mask);
+        (self.device_fn_1_0.cmd_set_event)(command_buffer, event, stage_mask);
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetEvent.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdResetEvent.html>
+    #[inline]
     pub unsafe fn cmd_reset_event(
         &self,
         command_buffer: vk::CommandBuffer,
         event: vk::Event,
         stage_mask: vk::PipelineStageFlags,
     ) {
-        self.device_fn_1_0
-            .cmd_reset_event(command_buffer, event, stage_mask);
+        (self.device_fn_1_0.cmd_reset_event)(command_buffer, event, stage_mask);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWaitEvents.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWaitEvents.html>
+    #[inline]
     pub unsafe fn cmd_wait_events(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -542,7 +1078,7 @@ impl Device {
         buffer_memory_barriers: &[vk::BufferMemoryBarrier],
         image_memory_barriers: &[vk::ImageMemoryBarrier],
     ) {
-        self.device_fn_1_0.cmd_wait_events(
+        (self.device_fn_1_0.cmd_wait_events)(
             command_buffer,
             events.len() as _,
             events.as_ptr(),
@@ -557,225 +1093,242 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyFence.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyFence.html>
+    #[inline]
     pub unsafe fn destroy_fence(
         &self,
         fence: vk::Fence,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0
-            .destroy_fence(self.handle(), fence, allocation_callbacks.as_raw_ptr());
+        (self.device_fn_1_0.destroy_fence)(self.handle(), fence, allocation_callbacks.as_raw_ptr());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyEvent.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyEvent.html>
+    #[inline]
     pub unsafe fn destroy_event(
         &self,
         event: vk::Event,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0
-            .destroy_event(self.handle(), event, allocation_callbacks.as_raw_ptr());
+        (self.device_fn_1_0.destroy_event)(self.handle(), event, allocation_callbacks.as_raw_ptr());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyImage.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyImage.html>
+    #[inline]
     pub unsafe fn destroy_image(
         &self,
         image: vk::Image,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0
-            .destroy_image(self.handle(), image, allocation_callbacks.as_raw_ptr());
+        (self.device_fn_1_0.destroy_image)(self.handle(), image, allocation_callbacks.as_raw_ptr());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyCommandPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyCommandPool.html>
+    #[inline]
     pub unsafe fn destroy_command_pool(
         &self,
         pool: vk::CommandPool,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_command_pool(
+        (self.device_fn_1_0.destroy_command_pool)(
             self.handle(),
             pool,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyImageView.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyImageView.html>
+    #[inline]
     pub unsafe fn destroy_image_view(
         &self,
         image_view: vk::ImageView,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_image_view(
+        (self.device_fn_1_0.destroy_image_view)(
             self.handle(),
             image_view,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyRenderPass.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyRenderPass.html>
+    #[inline]
     pub unsafe fn destroy_render_pass(
         &self,
         renderpass: vk::RenderPass,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_render_pass(
+        (self.device_fn_1_0.destroy_render_pass)(
             self.handle(),
             renderpass,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyFramebuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyFramebuffer.html>
+    #[inline]
     pub unsafe fn destroy_framebuffer(
         &self,
         framebuffer: vk::Framebuffer,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_framebuffer(
+        (self.device_fn_1_0.destroy_framebuffer)(
             self.handle(),
             framebuffer,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipelineLayout.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyPipelineLayout.html>
+    #[inline]
     pub unsafe fn destroy_pipeline_layout(
         &self,
         pipeline_layout: vk::PipelineLayout,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_pipeline_layout(
+        (self.device_fn_1_0.destroy_pipeline_layout)(
             self.handle(),
             pipeline_layout,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipelineCache.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyPipelineCache.html>
+    #[inline]
     pub unsafe fn destroy_pipeline_cache(
         &self,
         pipeline_cache: vk::PipelineCache,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_pipeline_cache(
+        (self.device_fn_1_0.destroy_pipeline_cache)(
             self.handle(),
             pipeline_cache,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyBuffer.html>
+    #[inline]
     pub unsafe fn destroy_buffer(
         &self,
         buffer: vk::Buffer,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0
-            .destroy_buffer(self.handle(), buffer, allocation_callbacks.as_raw_ptr());
+        (self.device_fn_1_0.destroy_buffer)(
+            self.handle(),
+            buffer,
+            allocation_callbacks.as_raw_ptr(),
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyShaderModule.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyShaderModule.html>
+    #[inline]
     pub unsafe fn destroy_shader_module(
         &self,
         shader: vk::ShaderModule,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_shader_module(
+        (self.device_fn_1_0.destroy_shader_module)(
             self.handle(),
             shader,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipeline.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyPipeline.html>
+    #[inline]
     pub unsafe fn destroy_pipeline(
         &self,
         pipeline: vk::Pipeline,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_pipeline(
+        (self.device_fn_1_0.destroy_pipeline)(
             self.handle(),
             pipeline,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySemaphore.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroySemaphore.html>
+    #[inline]
     pub unsafe fn destroy_semaphore(
         &self,
         semaphore: vk::Semaphore,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_semaphore(
+        (self.device_fn_1_0.destroy_semaphore)(
             self.handle(),
             semaphore,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDescriptorPool.html>
+    #[inline]
     pub unsafe fn destroy_descriptor_pool(
         &self,
         pool: vk::DescriptorPool,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_descriptor_pool(
+        (self.device_fn_1_0.destroy_descriptor_pool)(
             self.handle(),
             pool,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyQueryPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyQueryPool.html>
+    #[inline]
     pub unsafe fn destroy_query_pool(
         &self,
         pool: vk::QueryPool,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_query_pool(
+        (self.device_fn_1_0.destroy_query_pool)(
             self.handle(),
             pool,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorSetLayout.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDescriptorSetLayout.html>
+    #[inline]
     pub unsafe fn destroy_descriptor_set_layout(
         &self,
         layout: vk::DescriptorSetLayout,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_descriptor_set_layout(
+        (self.device_fn_1_0.destroy_descriptor_set_layout)(
             self.handle(),
             layout,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeDescriptorSets.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkFreeDescriptorSets.html>
+    #[inline]
     pub unsafe fn free_descriptor_sets(
         &self,
         pool: vk::DescriptorPool,
         descriptor_sets: &[vk::DescriptorSet],
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .free_descriptor_sets(
-                self.handle(),
-                pool,
-                descriptor_sets.len() as u32,
-                descriptor_sets.as_ptr(),
-            )
-            .into()
+        (self.device_fn_1_0.free_descriptor_sets)(
+            self.handle(),
+            pool,
+            descriptor_sets.len() as u32,
+            descriptor_sets.as_ptr(),
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateDescriptorSets.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkUpdateDescriptorSets.html>
+    #[inline]
     pub unsafe fn update_descriptor_sets(
         &self,
         descriptor_writes: &[vk::WriteDescriptorSet],
         descriptor_copies: &[vk::CopyDescriptorSet],
     ) {
-        self.device_fn_1_0.update_descriptor_sets(
+        (self.device_fn_1_0.update_descriptor_sets)(
             self.handle(),
             descriptor_writes.len() as u32,
             descriptor_writes.as_ptr(),
@@ -784,24 +1337,25 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSampler.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateSampler.html>
+    #[inline]
     pub unsafe fn create_sampler(
         &self,
         create_info: &vk::SamplerCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::Sampler> {
         let mut sampler = mem::zeroed();
-        self.device_fn_1_0
-            .create_sampler(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut sampler,
-            )
-            .result_with_success(sampler)
+        (self.device_fn_1_0.create_sampler)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut sampler,
+        )
+        .result_with_success(sampler)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBlitImage.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBlitImage.html>
+    #[inline]
     pub unsafe fn cmd_blit_image(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -812,7 +1366,7 @@ impl Device {
         regions: &[vk::ImageBlit],
         filter: vk::Filter,
     ) {
-        self.device_fn_1_0.cmd_blit_image(
+        (self.device_fn_1_0.cmd_blit_image)(
             command_buffer,
             src_image,
             src_image_layout,
@@ -824,7 +1378,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResolveImage.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdResolveImage.html>
+    #[inline]
     pub unsafe fn cmd_resolve_image(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -834,7 +1389,7 @@ impl Device {
         dst_image_layout: vk::ImageLayout,
         regions: &[vk::ImageResolve],
     ) {
-        self.device_fn_1_0.cmd_resolve_image(
+        (self.device_fn_1_0.cmd_resolve_image)(
             command_buffer,
             src_image,
             src_image_layout,
@@ -845,7 +1400,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdFillBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdFillBuffer.html>
+    #[inline]
     pub unsafe fn cmd_fill_buffer(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -854,11 +1410,11 @@ impl Device {
         size: vk::DeviceSize,
         data: u32,
     ) {
-        self.device_fn_1_0
-            .cmd_fill_buffer(command_buffer, buffer, offset, size, data);
+        (self.device_fn_1_0.cmd_fill_buffer)(command_buffer, buffer, offset, size, data);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdUpdateBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdUpdateBuffer.html>
+    #[inline]
     pub unsafe fn cmd_update_buffer(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -866,7 +1422,7 @@ impl Device {
         offset: vk::DeviceSize,
         data: &[u8],
     ) {
-        self.device_fn_1_0.cmd_update_buffer(
+        (self.device_fn_1_0.cmd_update_buffer)(
             command_buffer,
             buffer,
             offset,
@@ -875,7 +1431,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyBuffer.html>
+    #[inline]
     pub unsafe fn cmd_copy_buffer(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -883,7 +1440,7 @@ impl Device {
         dst_buffer: vk::Buffer,
         regions: &[vk::BufferCopy],
     ) {
-        self.device_fn_1_0.cmd_copy_buffer(
+        (self.device_fn_1_0.cmd_copy_buffer)(
             command_buffer,
             src_buffer,
             dst_buffer,
@@ -892,7 +1449,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImageToBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyImageToBuffer.html>
+    #[inline]
     pub unsafe fn cmd_copy_image_to_buffer(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -901,7 +1459,7 @@ impl Device {
         dst_buffer: vk::Buffer,
         regions: &[vk::BufferImageCopy],
     ) {
-        self.device_fn_1_0.cmd_copy_image_to_buffer(
+        (self.device_fn_1_0.cmd_copy_image_to_buffer)(
             command_buffer,
             src_image,
             src_image_layout,
@@ -911,7 +1469,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBufferToImage.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyBufferToImage.html>
+    #[inline]
     pub unsafe fn cmd_copy_buffer_to_image(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -920,7 +1479,7 @@ impl Device {
         dst_image_layout: vk::ImageLayout,
         regions: &[vk::BufferImageCopy],
     ) {
-        self.device_fn_1_0.cmd_copy_buffer_to_image(
+        (self.device_fn_1_0.cmd_copy_buffer_to_image)(
             command_buffer,
             src_buffer,
             dst_image,
@@ -930,7 +1489,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImage.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyImage.html>
+    #[inline]
     pub unsafe fn cmd_copy_image(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -940,7 +1500,7 @@ impl Device {
         dst_image_layout: vk::ImageLayout,
         regions: &[vk::ImageCopy],
     ) {
-        self.device_fn_1_0.cmd_copy_image(
+        (self.device_fn_1_0.cmd_copy_image)(
             command_buffer,
             src_image,
             src_image_layout,
@@ -951,102 +1511,103 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateDescriptorSets.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAllocateDescriptorSets.html>
+    #[inline]
     pub unsafe fn allocate_descriptor_sets(
         &self,
-        create_info: &vk::DescriptorSetAllocateInfo,
+        allocate_info: &vk::DescriptorSetAllocateInfo,
     ) -> VkResult<Vec<vk::DescriptorSet>> {
-        let mut desc_set = Vec::with_capacity(create_info.descriptor_set_count as usize);
-        let err_code = self.device_fn_1_0.allocate_descriptor_sets(
+        let mut desc_set = Vec::with_capacity(allocate_info.descriptor_set_count as usize);
+        (self.device_fn_1_0.allocate_descriptor_sets)(
             self.handle(),
-            create_info,
+            allocate_info,
             desc_set.as_mut_ptr(),
-        );
+        )
+        .result()?;
 
-        desc_set.set_len(create_info.descriptor_set_count as usize);
-        err_code.result_with_success(desc_set)
+        desc_set.set_len(allocate_info.descriptor_set_count as usize);
+        Ok(desc_set)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorSetLayout.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDescriptorSetLayout.html>
+    #[inline]
     pub unsafe fn create_descriptor_set_layout(
         &self,
         create_info: &vk::DescriptorSetLayoutCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DescriptorSetLayout> {
         let mut layout = mem::zeroed();
-        self.device_fn_1_0
-            .create_descriptor_set_layout(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut layout,
-            )
-            .result_with_success(layout)
+        (self.device_fn_1_0.create_descriptor_set_layout)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut layout,
+        )
+        .result_with_success(layout)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDeviceWaitIdle.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDeviceWaitIdle.html>
+    #[inline]
     pub unsafe fn device_wait_idle(&self) -> VkResult<()> {
-        self.device_fn_1_0.device_wait_idle(self.handle()).into()
+        (self.device_fn_1_0.device_wait_idle)(self.handle()).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDescriptorPool.html>
+    #[inline]
     pub unsafe fn create_descriptor_pool(
         &self,
         create_info: &vk::DescriptorPoolCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DescriptorPool> {
         let mut pool = mem::zeroed();
-        self.device_fn_1_0
-            .create_descriptor_pool(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut pool,
-            )
-            .result_with_success(pool)
+        (self.device_fn_1_0.create_descriptor_pool)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut pool,
+        )
+        .result_with_success(pool)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetDescriptorPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkResetDescriptorPool.html>
+    #[inline]
     pub unsafe fn reset_descriptor_pool(
         &self,
         pool: vk::DescriptorPool,
         flags: vk::DescriptorPoolResetFlags,
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .reset_descriptor_pool(self.handle(), pool, flags)
-            .into()
+        (self.device_fn_1_0.reset_descriptor_pool)(self.handle(), pool, flags).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetCommandPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkResetCommandPool.html>
+    #[inline]
     pub unsafe fn reset_command_pool(
         &self,
         command_pool: vk::CommandPool,
         flags: vk::CommandPoolResetFlags,
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .reset_command_pool(self.handle(), command_pool, flags)
-            .into()
+        (self.device_fn_1_0.reset_command_pool)(self.handle(), command_pool, flags).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetCommandBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkResetCommandBuffer.html>
+    #[inline]
     pub unsafe fn reset_command_buffer(
         &self,
         command_buffer: vk::CommandBuffer,
         flags: vk::CommandBufferResetFlags,
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .reset_command_buffer(command_buffer, flags)
-            .into()
+        (self.device_fn_1_0.reset_command_buffer)(command_buffer, flags).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetFences.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkResetFences.html>
+    #[inline]
     pub unsafe fn reset_fences(&self, fences: &[vk::Fence]) -> VkResult<()> {
-        self.device_fn_1_0
-            .reset_fences(self.handle(), fences.len() as u32, fences.as_ptr())
-            .into()
+        (self.device_fn_1_0.reset_fences)(self.handle(), fences.len() as u32, fences.as_ptr())
+            .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindIndexBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindIndexBuffer.html>
+    #[inline]
     pub unsafe fn cmd_bind_index_buffer(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1054,11 +1615,11 @@ impl Device {
         offset: vk::DeviceSize,
         index_type: vk::IndexType,
     ) {
-        self.device_fn_1_0
-            .cmd_bind_index_buffer(command_buffer, buffer, offset, index_type);
+        (self.device_fn_1_0.cmd_bind_index_buffer)(command_buffer, buffer, offset, index_type);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearColorImage.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdClearColorImage.html>
+    #[inline]
     pub unsafe fn cmd_clear_color_image(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1067,7 +1628,7 @@ impl Device {
         clear_color_value: &vk::ClearColorValue,
         ranges: &[vk::ImageSubresourceRange],
     ) {
-        self.device_fn_1_0.cmd_clear_color_image(
+        (self.device_fn_1_0.cmd_clear_color_image)(
             command_buffer,
             image,
             image_layout,
@@ -1077,7 +1638,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearDepthStencilImage.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdClearDepthStencilImage.html>
+    #[inline]
     pub unsafe fn cmd_clear_depth_stencil_image(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1086,7 +1648,7 @@ impl Device {
         clear_depth_stencil_value: &vk::ClearDepthStencilValue,
         ranges: &[vk::ImageSubresourceRange],
     ) {
-        self.device_fn_1_0.cmd_clear_depth_stencil_image(
+        (self.device_fn_1_0.cmd_clear_depth_stencil_image)(
             command_buffer,
             image,
             image_layout,
@@ -1096,14 +1658,15 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearAttachments.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdClearAttachments.html>
+    #[inline]
     pub unsafe fn cmd_clear_attachments(
         &self,
         command_buffer: vk::CommandBuffer,
         attachments: &[vk::ClearAttachment],
         rects: &[vk::ClearRect],
     ) {
-        self.device_fn_1_0.cmd_clear_attachments(
+        (self.device_fn_1_0.cmd_clear_attachments)(
             command_buffer,
             attachments.len() as u32,
             attachments.as_ptr(),
@@ -1112,7 +1675,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexed.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawIndexed.html>
+    #[inline]
     pub unsafe fn cmd_draw_indexed(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1122,7 +1686,7 @@ impl Device {
         vertex_offset: i32,
         first_instance: u32,
     ) {
-        self.device_fn_1_0.cmd_draw_indexed(
+        (self.device_fn_1_0.cmd_draw_indexed)(
             command_buffer,
             index_count,
             instance_count,
@@ -1132,7 +1696,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirect.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawIndexedIndirect.html>
+    #[inline]
     pub unsafe fn cmd_draw_indexed_indirect(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1141,7 +1706,7 @@ impl Device {
         draw_count: u32,
         stride: u32,
     ) {
-        self.device_fn_1_0.cmd_draw_indexed_indirect(
+        (self.device_fn_1_0.cmd_draw_indexed_indirect)(
             command_buffer,
             buffer,
             offset,
@@ -1150,20 +1715,22 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdExecuteCommands.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdExecuteCommands.html>
+    #[inline]
     pub unsafe fn cmd_execute_commands(
         &self,
         primary_command_buffer: vk::CommandBuffer,
         secondary_command_buffers: &[vk::CommandBuffer],
     ) {
-        self.device_fn_1_0.cmd_execute_commands(
+        (self.device_fn_1_0.cmd_execute_commands)(
             primary_command_buffer,
             secondary_command_buffers.len() as u32,
             secondary_command_buffers.as_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindDescriptorSets.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindDescriptorSets.html>
+    #[inline]
     pub unsafe fn cmd_bind_descriptor_sets(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1173,7 +1740,7 @@ impl Device {
         descriptor_sets: &[vk::DescriptorSet],
         dynamic_offsets: &[u32],
     ) {
-        self.device_fn_1_0.cmd_bind_descriptor_sets(
+        (self.device_fn_1_0.cmd_bind_descriptor_sets)(
             command_buffer,
             pipeline_bind_point,
             layout,
@@ -1185,7 +1752,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyQueryPoolResults.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyQueryPoolResults.html>
+    #[inline]
     pub unsafe fn cmd_copy_query_pool_results(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1197,7 +1765,7 @@ impl Device {
         stride: vk::DeviceSize,
         flags: vk::QueryResultFlags,
     ) {
-        self.device_fn_1_0.cmd_copy_query_pool_results(
+        (self.device_fn_1_0.cmd_copy_query_pool_results)(
             command_buffer,
             query_pool,
             first_query,
@@ -1209,7 +1777,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushConstants.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdPushConstants.html>
+    #[inline]
     pub unsafe fn cmd_push_constants(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1218,7 +1787,7 @@ impl Device {
         offset: u32,
         constants: &[u8],
     ) {
-        self.device_fn_1_0.cmd_push_constants(
+        (self.device_fn_1_0.cmd_push_constants)(
             command_buffer,
             layout,
             stage_flags,
@@ -1228,46 +1797,47 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginRenderPass.html>
+    #[inline]
     pub unsafe fn cmd_begin_render_pass(
         &self,
         command_buffer: vk::CommandBuffer,
-        create_info: &vk::RenderPassBeginInfo,
+        render_pass_begin: &vk::RenderPassBeginInfo,
         contents: vk::SubpassContents,
     ) {
-        self.device_fn_1_0
-            .cmd_begin_render_pass(command_buffer, create_info, contents);
+        (self.device_fn_1_0.cmd_begin_render_pass)(command_buffer, render_pass_begin, contents);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdNextSubpass.html>
+    #[inline]
     pub unsafe fn cmd_next_subpass(
         &self,
         command_buffer: vk::CommandBuffer,
         contents: vk::SubpassContents,
     ) {
-        self.device_fn_1_0
-            .cmd_next_subpass(command_buffer, contents);
+        (self.device_fn_1_0.cmd_next_subpass)(command_buffer, contents);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindPipeline.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindPipeline.html>
+    #[inline]
     pub unsafe fn cmd_bind_pipeline(
         &self,
         command_buffer: vk::CommandBuffer,
         pipeline_bind_point: vk::PipelineBindPoint,
         pipeline: vk::Pipeline,
     ) {
-        self.device_fn_1_0
-            .cmd_bind_pipeline(command_buffer, pipeline_bind_point, pipeline);
+        (self.device_fn_1_0.cmd_bind_pipeline)(command_buffer, pipeline_bind_point, pipeline);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetScissor.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetScissor.html>
+    #[inline]
     pub unsafe fn cmd_set_scissor(
         &self,
         command_buffer: vk::CommandBuffer,
         first_scissor: u32,
         scissors: &[vk::Rect2D],
     ) {
-        self.device_fn_1_0.cmd_set_scissor(
+        (self.device_fn_1_0.cmd_set_scissor)(
             command_buffer,
             first_scissor,
             scissors.len() as u32,
@@ -1275,13 +1845,14 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetLineWidth.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineWidth.html>
+    #[inline]
     pub unsafe fn cmd_set_line_width(&self, command_buffer: vk::CommandBuffer, line_width: f32) {
-        self.device_fn_1_0
-            .cmd_set_line_width(command_buffer, line_width);
+        (self.device_fn_1_0.cmd_set_line_width)(command_buffer, line_width);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindVertexBuffers.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindVertexBuffers.html>
+    #[inline]
     pub unsafe fn cmd_bind_vertex_buffers(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1290,7 +1861,7 @@ impl Device {
         offsets: &[vk::DeviceSize],
     ) {
         debug_assert_eq!(buffers.len(), offsets.len());
-        self.device_fn_1_0.cmd_bind_vertex_buffers(
+        (self.device_fn_1_0.cmd_bind_vertex_buffers)(
             command_buffer,
             first_binding,
             buffers.len() as u32,
@@ -1299,12 +1870,14 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndRenderPass.html>
+    #[inline]
     pub unsafe fn cmd_end_render_pass(&self, command_buffer: vk::CommandBuffer) {
-        self.device_fn_1_0.cmd_end_render_pass(command_buffer);
+        (self.device_fn_1_0.cmd_end_render_pass)(command_buffer);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDraw.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDraw.html>
+    #[inline]
     pub unsafe fn cmd_draw(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1313,7 +1886,7 @@ impl Device {
         first_vertex: u32,
         first_instance: u32,
     ) {
-        self.device_fn_1_0.cmd_draw(
+        (self.device_fn_1_0.cmd_draw)(
             command_buffer,
             vertex_count,
             instance_count,
@@ -1322,7 +1895,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirect.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawIndirect.html>
+    #[inline]
     pub unsafe fn cmd_draw_indirect(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1331,11 +1905,11 @@ impl Device {
         draw_count: u32,
         stride: u32,
     ) {
-        self.device_fn_1_0
-            .cmd_draw_indirect(command_buffer, buffer, offset, draw_count, stride);
+        (self.device_fn_1_0.cmd_draw_indirect)(command_buffer, buffer, offset, draw_count, stride);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatch.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDispatch.html>
+    #[inline]
     pub unsafe fn cmd_dispatch(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1343,7 +1917,7 @@ impl Device {
         group_count_y: u32,
         group_count_z: u32,
     ) {
-        self.device_fn_1_0.cmd_dispatch(
+        (self.device_fn_1_0.cmd_dispatch)(
             command_buffer,
             group_count_x,
             group_count_y,
@@ -1351,25 +1925,26 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatchIndirect.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDispatchIndirect.html>
+    #[inline]
     pub unsafe fn cmd_dispatch_indirect(
         &self,
         command_buffer: vk::CommandBuffer,
         buffer: vk::Buffer,
         offset: vk::DeviceSize,
     ) {
-        self.device_fn_1_0
-            .cmd_dispatch_indirect(command_buffer, buffer, offset);
+        (self.device_fn_1_0.cmd_dispatch_indirect)(command_buffer, buffer, offset);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetViewport.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewport.html>
+    #[inline]
     pub unsafe fn cmd_set_viewport(
         &self,
         command_buffer: vk::CommandBuffer,
         first_viewport: u32,
         viewports: &[vk::Viewport],
     ) {
-        self.device_fn_1_0.cmd_set_viewport(
+        (self.device_fn_1_0.cmd_set_viewport)(
             command_buffer,
             first_viewport,
             viewports.len() as u32,
@@ -1377,7 +1952,8 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBias.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBias.html>
+    #[inline]
     pub unsafe fn cmd_set_depth_bias(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1385,65 +1961,74 @@ impl Device {
         clamp: f32,
         slope_factor: f32,
     ) {
-        self.device_fn_1_0
-            .cmd_set_depth_bias(command_buffer, constant_factor, clamp, slope_factor);
+        (self.device_fn_1_0.cmd_set_depth_bias)(
+            command_buffer,
+            constant_factor,
+            clamp,
+            slope_factor,
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetBlendConstants.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetBlendConstants.html>
+    #[inline]
     pub unsafe fn cmd_set_blend_constants(
         &self,
         command_buffer: vk::CommandBuffer,
         blend_constants: &[f32; 4],
     ) {
-        self.device_fn_1_0
-            .cmd_set_blend_constants(command_buffer, blend_constants);
+        (self.device_fn_1_0.cmd_set_blend_constants)(command_buffer, blend_constants);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBounds.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBounds.html>
+    #[inline]
     pub unsafe fn cmd_set_depth_bounds(
         &self,
         command_buffer: vk::CommandBuffer,
         min_depth_bounds: f32,
         max_depth_bounds: f32,
     ) {
-        self.device_fn_1_0
-            .cmd_set_depth_bounds(command_buffer, min_depth_bounds, max_depth_bounds);
+        (self.device_fn_1_0.cmd_set_depth_bounds)(
+            command_buffer,
+            min_depth_bounds,
+            max_depth_bounds,
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilCompareMask.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilCompareMask.html>
+    #[inline]
     pub unsafe fn cmd_set_stencil_compare_mask(
         &self,
         command_buffer: vk::CommandBuffer,
         face_mask: vk::StencilFaceFlags,
         compare_mask: u32,
     ) {
-        self.device_fn_1_0
-            .cmd_set_stencil_compare_mask(command_buffer, face_mask, compare_mask);
+        (self.device_fn_1_0.cmd_set_stencil_compare_mask)(command_buffer, face_mask, compare_mask);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilWriteMask.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilWriteMask.html>
+    #[inline]
     pub unsafe fn cmd_set_stencil_write_mask(
         &self,
         command_buffer: vk::CommandBuffer,
         face_mask: vk::StencilFaceFlags,
         write_mask: u32,
     ) {
-        self.device_fn_1_0
-            .cmd_set_stencil_write_mask(command_buffer, face_mask, write_mask);
+        (self.device_fn_1_0.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilReference.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilReference.html>
+    #[inline]
     pub unsafe fn cmd_set_stencil_reference(
         &self,
         command_buffer: vk::CommandBuffer,
         face_mask: vk::StencilFaceFlags,
         reference: u32,
     ) {
-        self.device_fn_1_0
-            .cmd_set_stencil_reference(command_buffer, face_mask, reference);
+        (self.device_fn_1_0.cmd_set_stencil_reference)(command_buffer, face_mask, reference);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetQueryPoolResults.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetQueryPoolResults.html>
+    #[inline]
     pub unsafe fn get_query_pool_results<T>(
         &self,
         query_pool: vk::QueryPool,
@@ -1458,21 +2043,21 @@ impl Device {
             "query_count was higher than the length of the slice"
         );
         let data_size = mem::size_of::<T>() * data_length;
-        self.device_fn_1_0
-            .get_query_pool_results(
-                self.handle(),
-                query_pool,
-                first_query,
-                query_count,
-                data_size,
-                data.as_mut_ptr() as *mut _,
-                mem::size_of::<T>() as _,
-                flags,
-            )
-            .into()
+        (self.device_fn_1_0.get_query_pool_results)(
+            self.handle(),
+            query_pool,
+            first_query,
+            query_count,
+            data_size,
+            data.as_mut_ptr().cast(),
+            mem::size_of::<T>() as _,
+            flags,
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginQuery.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginQuery.html>
+    #[inline]
     pub unsafe fn cmd_begin_query(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1480,22 +2065,22 @@ impl Device {
         query: u32,
         flags: vk::QueryControlFlags,
     ) {
-        self.device_fn_1_0
-            .cmd_begin_query(command_buffer, query_pool, query, flags);
+        (self.device_fn_1_0.cmd_begin_query)(command_buffer, query_pool, query, flags);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndQuery.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndQuery.html>
+    #[inline]
     pub unsafe fn cmd_end_query(
         &self,
         command_buffer: vk::CommandBuffer,
         query_pool: vk::QueryPool,
         query: u32,
     ) {
-        self.device_fn_1_0
-            .cmd_end_query(command_buffer, query_pool, query);
+        (self.device_fn_1_0.cmd_end_query)(command_buffer, query_pool, query);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetQueryPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdResetQueryPool.html>
+    #[inline]
     pub unsafe fn cmd_reset_query_pool(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1503,11 +2088,11 @@ impl Device {
         first_query: u32,
         query_count: u32,
     ) {
-        self.device_fn_1_0
-            .cmd_reset_query_pool(command_buffer, pool, first_query, query_count);
+        (self.device_fn_1_0.cmd_reset_query_pool)(command_buffer, pool, first_query, query_count);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWriteTimestamp.html>
+    #[inline]
     pub unsafe fn cmd_write_timestamp(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1515,28 +2100,28 @@ impl Device {
         query_pool: vk::QueryPool,
         query: u32,
     ) {
-        self.device_fn_1_0
-            .cmd_write_timestamp(command_buffer, pipeline_stage, query_pool, query);
+        (self.device_fn_1_0.cmd_write_timestamp)(command_buffer, pipeline_stage, query_pool, query);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSemaphore.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateSemaphore.html>
+    #[inline]
     pub unsafe fn create_semaphore(
         &self,
         create_info: &vk::SemaphoreCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::Semaphore> {
         let mut semaphore = mem::zeroed();
-        self.device_fn_1_0
-            .create_semaphore(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut semaphore,
-            )
-            .result_with_success(semaphore)
+        (self.device_fn_1_0.create_semaphore)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut semaphore,
+        )
+        .result_with_success(semaphore)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateGraphicsPipelines.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateGraphicsPipelines.html>
+    #[inline]
     pub unsafe fn create_graphics_pipelines(
         &self,
         pipeline_cache: vk::PipelineCache,
@@ -1544,7 +2129,7 @@ impl Device {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> Result<Vec<vk::Pipeline>, (Vec<vk::Pipeline>, vk::Result)> {
         let mut pipelines = Vec::with_capacity(create_infos.len());
-        let err_code = self.device_fn_1_0.create_graphics_pipelines(
+        let err_code = (self.device_fn_1_0.create_graphics_pipelines)(
             self.handle(),
             pipeline_cache,
             create_infos.len() as u32,
@@ -1559,7 +2144,8 @@ impl Device {
         }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateComputePipelines.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateComputePipelines.html>
+    #[inline]
     pub unsafe fn create_compute_pipelines(
         &self,
         pipeline_cache: vk::PipelineCache,
@@ -1567,7 +2153,7 @@ impl Device {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> Result<Vec<vk::Pipeline>, (Vec<vk::Pipeline>, vk::Result)> {
         let mut pipelines = Vec::with_capacity(create_infos.len());
-        let err_code = self.device_fn_1_0.create_compute_pipelines(
+        let err_code = (self.device_fn_1_0.create_compute_pipelines)(
             self.handle(),
             pipeline_cache,
             create_infos.len() as u32,
@@ -1582,64 +2168,65 @@ impl Device {
         }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateBuffer.html>
+    #[inline]
     pub unsafe fn create_buffer(
         &self,
         create_info: &vk::BufferCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::Buffer> {
         let mut buffer = mem::zeroed();
-        self.device_fn_1_0
-            .create_buffer(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut buffer,
-            )
-            .result_with_success(buffer)
+        (self.device_fn_1_0.create_buffer)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut buffer,
+        )
+        .result_with_success(buffer)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreatePipelineLayout.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreatePipelineLayout.html>
+    #[inline]
     pub unsafe fn create_pipeline_layout(
         &self,
         create_info: &vk::PipelineLayoutCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::PipelineLayout> {
         let mut pipeline_layout = mem::zeroed();
-        self.device_fn_1_0
-            .create_pipeline_layout(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut pipeline_layout,
-            )
-            .result_with_success(pipeline_layout)
+        (self.device_fn_1_0.create_pipeline_layout)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut pipeline_layout,
+        )
+        .result_with_success(pipeline_layout)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreatePipelineCache.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreatePipelineCache.html>
+    #[inline]
     pub unsafe fn create_pipeline_cache(
         &self,
         create_info: &vk::PipelineCacheCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::PipelineCache> {
         let mut pipeline_cache = mem::zeroed();
-        self.device_fn_1_0
-            .create_pipeline_cache(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut pipeline_cache,
-            )
-            .result_with_success(pipeline_cache)
+        (self.device_fn_1_0.create_pipeline_cache)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut pipeline_cache,
+        )
+        .result_with_success(pipeline_cache)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineCacheData.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPipelineCacheData.html>
+    #[inline]
     pub unsafe fn get_pipeline_cache_data(
         &self,
         pipeline_cache: vk::PipelineCache,
     ) -> VkResult<Vec<u8>> {
         read_into_uninitialized_vector(|count, data| {
-            self.device_fn_1_0.get_pipeline_cache_data(
+            (self.device_fn_1_0.get_pipeline_cache_data)(
                 self.handle(),
                 pipeline_cache,
                 count,
@@ -1648,23 +2235,24 @@ impl Device {
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMergePipelineCaches.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkMergePipelineCaches.html>
+    #[inline]
     pub unsafe fn merge_pipeline_caches(
         &self,
         dst_cache: vk::PipelineCache,
         src_caches: &[vk::PipelineCache],
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .merge_pipeline_caches(
-                self.handle(),
-                dst_cache,
-                src_caches.len() as u32,
-                src_caches.as_ptr(),
-            )
-            .into()
+        (self.device_fn_1_0.merge_pipeline_caches)(
+            self.handle(),
+            dst_cache,
+            src_caches.len() as u32,
+            src_caches.as_ptr(),
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMapMemory.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkMapMemory.html>
+    #[inline]
     pub unsafe fn map_memory(
         &self,
         memory: vk::DeviceMemory,
@@ -1673,57 +2261,66 @@ impl Device {
         flags: vk::MemoryMapFlags,
     ) -> VkResult<*mut c_void> {
         let mut data: *mut c_void = ptr::null_mut();
-        self.device_fn_1_0
-            .map_memory(self.handle(), memory, offset, size, flags, &mut data)
+        (self.device_fn_1_0.map_memory)(self.handle(), memory, offset, size, flags, &mut data)
             .result_with_success(data)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUnmapMemory.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkUnmapMemory.html>
+    #[inline]
     pub unsafe fn unmap_memory(&self, memory: vk::DeviceMemory) {
-        self.device_fn_1_0.unmap_memory(self.handle(), memory);
+        (self.device_fn_1_0.unmap_memory)(self.handle(), memory);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkInvalidateMappedMemoryRanges.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkInvalidateMappedMemoryRanges.html>
+    #[inline]
     pub unsafe fn invalidate_mapped_memory_ranges(
         &self,
         ranges: &[vk::MappedMemoryRange],
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .invalidate_mapped_memory_ranges(self.handle(), ranges.len() as u32, ranges.as_ptr())
-            .into()
+        (self.device_fn_1_0.invalidate_mapped_memory_ranges)(
+            self.handle(),
+            ranges.len() as u32,
+            ranges.as_ptr(),
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFlushMappedMemoryRanges.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkFlushMappedMemoryRanges.html>
+    #[inline]
     pub unsafe fn flush_mapped_memory_ranges(
         &self,
         ranges: &[vk::MappedMemoryRange],
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .flush_mapped_memory_ranges(self.handle(), ranges.len() as u32, ranges.as_ptr())
-            .into()
+        (self.device_fn_1_0.flush_mapped_memory_ranges)(
+            self.handle(),
+            ranges.len() as u32,
+            ranges.as_ptr(),
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateFramebuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateFramebuffer.html>
+    #[inline]
     pub unsafe fn create_framebuffer(
         &self,
         create_info: &vk::FramebufferCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::Framebuffer> {
         let mut framebuffer = mem::zeroed();
-        self.device_fn_1_0
-            .create_framebuffer(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut framebuffer,
-            )
-            .result_with_success(framebuffer)
+        (self.device_fn_1_0.create_framebuffer)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut framebuffer,
+        )
+        .result_with_success(framebuffer)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceQueue.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceQueue.html>
+    #[inline]
     pub unsafe fn get_device_queue(&self, queue_family_index: u32, queue_index: u32) -> vk::Queue {
         let mut queue = mem::zeroed();
-        self.device_fn_1_0.get_device_queue(
+        (self.device_fn_1_0.get_device_queue)(
             self.handle(),
             queue_family_index,
             queue_index,
@@ -1732,7 +2329,8 @@ impl Device {
         queue
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPipelineBarrier.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdPipelineBarrier.html>
+    #[inline]
     pub unsafe fn cmd_pipeline_barrier(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -1743,7 +2341,7 @@ impl Device {
         buffer_memory_barriers: &[vk::BufferMemoryBarrier],
         image_memory_barriers: &[vk::ImageMemoryBarrier],
     ) {
-        self.device_fn_1_0.cmd_pipeline_barrier(
+        (self.device_fn_1_0.cmd_pipeline_barrier)(
             command_buffer,
             src_stage_mask,
             dst_stage_mask,
@@ -1757,60 +2355,61 @@ impl Device {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateRenderPass.html>
+    #[inline]
     pub unsafe fn create_render_pass(
         &self,
         create_info: &vk::RenderPassCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::RenderPass> {
         let mut renderpass = mem::zeroed();
-        self.device_fn_1_0
-            .create_render_pass(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut renderpass,
-            )
-            .result_with_success(renderpass)
+        (self.device_fn_1_0.create_render_pass)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut renderpass,
+        )
+        .result_with_success(renderpass)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBeginCommandBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBeginCommandBuffer.html>
+    #[inline]
     pub unsafe fn begin_command_buffer(
         &self,
         command_buffer: vk::CommandBuffer,
         begin_info: &vk::CommandBufferBeginInfo,
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .begin_command_buffer(command_buffer, begin_info)
-            .into()
+        (self.device_fn_1_0.begin_command_buffer)(command_buffer, begin_info).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEndCommandBuffer.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEndCommandBuffer.html>
+    #[inline]
     pub unsafe fn end_command_buffer(&self, command_buffer: vk::CommandBuffer) -> VkResult<()> {
-        self.device_fn_1_0.end_command_buffer(command_buffer).into()
+        (self.device_fn_1_0.end_command_buffer)(command_buffer).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitForFences.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkWaitForFences.html>
+    #[inline]
     pub unsafe fn wait_for_fences(
         &self,
         fences: &[vk::Fence],
         wait_all: bool,
         timeout: u64,
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .wait_for_fences(
-                self.handle(),
-                fences.len() as u32,
-                fences.as_ptr(),
-                wait_all as u32,
-                timeout,
-            )
-            .into()
+        (self.device_fn_1_0.wait_for_fences)(
+            self.handle(),
+            fences.len() as u32,
+            fences.as_ptr(),
+            wait_all as u32,
+            timeout,
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetFenceStatus.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetFenceStatus.html>
+    #[inline]
     pub unsafe fn get_fence_status(&self, fence: vk::Fence) -> VkResult<bool> {
-        let err_code = self.device_fn_1_0.get_fence_status(self.handle(), fence);
+        let err_code = (self.device_fn_1_0.get_fence_status)(self.handle(), fence);
         match err_code {
             vk::Result::SUCCESS => Ok(true),
             vk::Result::NOT_READY => Ok(false),
@@ -1818,156 +2417,166 @@ impl Device {
         }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueWaitIdle.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueWaitIdle.html>
+    #[inline]
     pub unsafe fn queue_wait_idle(&self, queue: vk::Queue) -> VkResult<()> {
-        self.device_fn_1_0.queue_wait_idle(queue).into()
+        (self.device_fn_1_0.queue_wait_idle)(queue).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueSubmit.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueSubmit.html>
+    #[inline]
     pub unsafe fn queue_submit(
         &self,
         queue: vk::Queue,
         submits: &[vk::SubmitInfo],
         fence: vk::Fence,
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .queue_submit(queue, submits.len() as u32, submits.as_ptr(), fence)
-            .into()
+        (self.device_fn_1_0.queue_submit)(queue, submits.len() as u32, submits.as_ptr(), fence)
+            .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueBindSparse.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueBindSparse.html>
+    #[inline]
     pub unsafe fn queue_bind_sparse(
         &self,
         queue: vk::Queue,
         bind_info: &[vk::BindSparseInfo],
         fence: vk::Fence,
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .queue_bind_sparse(queue, bind_info.len() as u32, bind_info.as_ptr(), fence)
-            .into()
+        (self.device_fn_1_0.queue_bind_sparse)(
+            queue,
+            bind_info.len() as u32,
+            bind_info.as_ptr(),
+            fence,
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateBufferView.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateBufferView.html>
+    #[inline]
     pub unsafe fn create_buffer_view(
         &self,
         create_info: &vk::BufferViewCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::BufferView> {
         let mut buffer_view = mem::zeroed();
-        self.device_fn_1_0
-            .create_buffer_view(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut buffer_view,
-            )
-            .result_with_success(buffer_view)
+        (self.device_fn_1_0.create_buffer_view)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut buffer_view,
+        )
+        .result_with_success(buffer_view)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyBufferView.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyBufferView.html>
+    #[inline]
     pub unsafe fn destroy_buffer_view(
         &self,
         buffer_view: vk::BufferView,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.device_fn_1_0.destroy_buffer_view(
+        (self.device_fn_1_0.destroy_buffer_view)(
             self.handle(),
             buffer_view,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImageView.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateImageView.html>
+    #[inline]
     pub unsafe fn create_image_view(
         &self,
         create_info: &vk::ImageViewCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::ImageView> {
         let mut image_view = mem::zeroed();
-        self.device_fn_1_0
-            .create_image_view(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut image_view,
-            )
-            .result_with_success(image_view)
+        (self.device_fn_1_0.create_image_view)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut image_view,
+        )
+        .result_with_success(image_view)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateCommandBuffers.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAllocateCommandBuffers.html>
+    #[inline]
     pub unsafe fn allocate_command_buffers(
         &self,
-        create_info: &vk::CommandBufferAllocateInfo,
+        allocate_info: &vk::CommandBufferAllocateInfo,
     ) -> VkResult<Vec<vk::CommandBuffer>> {
-        let mut buffers = Vec::with_capacity(create_info.command_buffer_count as usize);
-        let err_code = self.device_fn_1_0.allocate_command_buffers(
+        let mut buffers = Vec::with_capacity(allocate_info.command_buffer_count as usize);
+        (self.device_fn_1_0.allocate_command_buffers)(
             self.handle(),
-            create_info,
+            allocate_info,
             buffers.as_mut_ptr(),
-        );
-        buffers.set_len(create_info.command_buffer_count as usize);
-        err_code.result_with_success(buffers)
+        )
+        .result()?;
+        buffers.set_len(allocate_info.command_buffer_count as usize);
+        Ok(buffers)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateCommandPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateCommandPool.html>
+    #[inline]
     pub unsafe fn create_command_pool(
         &self,
         create_info: &vk::CommandPoolCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::CommandPool> {
         let mut pool = mem::zeroed();
-        self.device_fn_1_0
-            .create_command_pool(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut pool,
-            )
-            .result_with_success(pool)
+        (self.device_fn_1_0.create_command_pool)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut pool,
+        )
+        .result_with_success(pool)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateQueryPool.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateQueryPool.html>
+    #[inline]
     pub unsafe fn create_query_pool(
         &self,
         create_info: &vk::QueryPoolCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::QueryPool> {
         let mut pool = mem::zeroed();
-        self.device_fn_1_0
-            .create_query_pool(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut pool,
-            )
-            .result_with_success(pool)
+        (self.device_fn_1_0.create_query_pool)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut pool,
+        )
+        .result_with_success(pool)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImage.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateImage.html>
+    #[inline]
     pub unsafe fn create_image(
         &self,
         create_info: &vk::ImageCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::Image> {
         let mut image = mem::zeroed();
-        self.device_fn_1_0
-            .create_image(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut image,
-            )
-            .result_with_success(image)
+        (self.device_fn_1_0.create_image)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut image,
+        )
+        .result_with_success(image)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSubresourceLayout.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageSubresourceLayout.html>
+    #[inline]
     pub unsafe fn get_image_subresource_layout(
         &self,
         image: vk::Image,
         subresource: vk::ImageSubresource,
     ) -> vk::SubresourceLayout {
         let mut layout = mem::zeroed();
-        self.device_fn_1_0.get_image_subresource_layout(
+        (self.device_fn_1_0.get_image_subresource_layout)(
             self.handle(),
             image,
             &subresource,
@@ -1976,104 +2585,104 @@ impl Device {
         layout
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageMemoryRequirements.html>
+    #[inline]
     pub unsafe fn get_image_memory_requirements(&self, image: vk::Image) -> vk::MemoryRequirements {
         let mut mem_req = mem::zeroed();
-        self.device_fn_1_0
-            .get_image_memory_requirements(self.handle(), image, &mut mem_req);
+        (self.device_fn_1_0.get_image_memory_requirements)(self.handle(), image, &mut mem_req);
         mem_req
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferMemoryRequirements.html>
+    #[inline]
     pub unsafe fn get_buffer_memory_requirements(
         &self,
         buffer: vk::Buffer,
     ) -> vk::MemoryRequirements {
         let mut mem_req = mem::zeroed();
-        self.device_fn_1_0
-            .get_buffer_memory_requirements(self.handle(), buffer, &mut mem_req);
+        (self.device_fn_1_0.get_buffer_memory_requirements)(self.handle(), buffer, &mut mem_req);
         mem_req
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateMemory.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAllocateMemory.html>
+    #[inline]
     pub unsafe fn allocate_memory(
         &self,
-        create_info: &vk::MemoryAllocateInfo,
+        allocate_info: &vk::MemoryAllocateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DeviceMemory> {
         let mut memory = mem::zeroed();
-        self.device_fn_1_0
-            .allocate_memory(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut memory,
-            )
-            .result_with_success(memory)
+        (self.device_fn_1_0.allocate_memory)(
+            self.handle(),
+            allocate_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut memory,
+        )
+        .result_with_success(memory)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateShaderModule.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateShaderModule.html>
+    #[inline]
     pub unsafe fn create_shader_module(
         &self,
         create_info: &vk::ShaderModuleCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::ShaderModule> {
         let mut shader = mem::zeroed();
-        self.device_fn_1_0
-            .create_shader_module(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut shader,
-            )
-            .result_with_success(shader)
+        (self.device_fn_1_0.create_shader_module)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut shader,
+        )
+        .result_with_success(shader)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateFence.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateFence.html>
+    #[inline]
     pub unsafe fn create_fence(
         &self,
         create_info: &vk::FenceCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::Fence> {
         let mut fence = mem::zeroed();
-        self.device_fn_1_0
-            .create_fence(
-                self.handle(),
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut fence,
-            )
-            .result_with_success(fence)
+        (self.device_fn_1_0.create_fence)(
+            self.handle(),
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut fence,
+        )
+        .result_with_success(fence)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindBufferMemory.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBindBufferMemory.html>
+    #[inline]
     pub unsafe fn bind_buffer_memory(
         &self,
         buffer: vk::Buffer,
         device_memory: vk::DeviceMemory,
         offset: vk::DeviceSize,
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .bind_buffer_memory(self.handle(), buffer, device_memory, offset)
-            .into()
+        (self.device_fn_1_0.bind_buffer_memory)(self.handle(), buffer, device_memory, offset)
+            .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindImageMemory.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBindImageMemory.html>
+    #[inline]
     pub unsafe fn bind_image_memory(
         &self,
         image: vk::Image,
         device_memory: vk::DeviceMemory,
         offset: vk::DeviceSize,
     ) -> VkResult<()> {
-        self.device_fn_1_0
-            .bind_image_memory(self.handle(), image, device_memory, offset)
-            .into()
+        (self.device_fn_1_0.bind_image_memory)(self.handle(), image, device_memory, offset).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRenderAreaGranularity.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRenderAreaGranularity.html>
+    #[inline]
     pub unsafe fn get_render_area_granularity(&self, render_pass: vk::RenderPass) -> vk::Extent2D {
         let mut granularity = mem::zeroed();
-        self.device_fn_1_0.get_render_area_granularity(
+        (self.device_fn_1_0.get_render_area_granularity)(
             self.handle(),
             render_pass,
             &mut granularity,
@@ -2081,10 +2690,11 @@ impl Device {
         granularity
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryCommitment.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceMemoryCommitment.html>
+    #[inline]
     pub unsafe fn get_device_memory_commitment(&self, memory: vk::DeviceMemory) -> vk::DeviceSize {
         let mut committed_memory_in_bytes = 0;
-        self.device_fn_1_0.get_device_memory_commitment(
+        (self.device_fn_1_0.get_device_memory_commitment)(
             self.handle(),
             memory,
             &mut committed_memory_in_bytes,
@@ -2092,13 +2702,14 @@ impl Device {
         committed_memory_in_bytes
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageSparseMemoryRequirements.html>
+    #[inline]
     pub unsafe fn get_image_sparse_memory_requirements(
         &self,
         image: vk::Image,
     ) -> Vec<vk::SparseImageMemoryRequirements> {
         read_into_uninitialized_vector(|count, data| {
-            self.device_fn_1_0.get_image_sparse_memory_requirements(
+            (self.device_fn_1_0.get_image_sparse_memory_requirements)(
                 self.handle(),
                 image,
                 count,
diff --git a/src/entry.rs b/src/entry.rs
index 280076b..7df62e7 100644
--- a/src/entry.rs
+++ b/src/entry.rs
@@ -2,70 +2,203 @@ use crate::instance::Instance;
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use std::error::Error;
 use std::ffi::CStr;
-use std::fmt;
+#[cfg(feature = "loaded")]
+use std::ffi::OsStr;
 use std::mem;
 use std::os::raw::c_char;
 use std::os::raw::c_void;
 use std::ptr;
+#[cfg(feature = "loaded")]
+use std::sync::Arc;
 
-/// Holds a custom type `L` to load symbols from (usually a handle to a `dlopen`ed library),
-/// the [`vkGetInstanceProcAddr`][vk::StaticFn::get_instance_proc_addr()] loader function from
-/// this library (in [`vk::StaticFn`]), and Vulkan's "entry point" functions (resolved with `NULL`
-/// `instance`) as listed in [`vkGetInstanceProcAddr`'s description].
-///
-/// [`vkGetInstanceProcAddr`'s description]: https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetInstanceProcAddr.html#_description
+#[cfg(feature = "loaded")]
+use libloading::Library;
+
+/// Holds the Vulkan functions independent of a particular instance
 #[derive(Clone)]
-pub struct EntryCustom<L> {
+pub struct Entry {
     static_fn: vk::StaticFn,
     entry_fn_1_0: vk::EntryFnV1_0,
     entry_fn_1_1: vk::EntryFnV1_1,
     entry_fn_1_2: vk::EntryFnV1_2,
-    lib: L,
+    entry_fn_1_3: vk::EntryFnV1_3,
+    #[cfg(feature = "loaded")]
+    _lib_guard: Option<Arc<Library>>,
 }
 
 /// Vulkan core 1.0
 #[allow(non_camel_case_types)]
-impl<L> EntryCustom<L> {
-    pub fn new_custom<Load>(
-        mut lib: L,
-        mut load: Load,
-    ) -> std::result::Result<Self, MissingEntryPoint>
-    where
-        Load: FnMut(&mut L, &::std::ffi::CStr) -> *const c_void,
-    {
-        // Bypass the normal StaticFn::load so we can return an error
-        let static_fn = vk::StaticFn::load_checked(|name| load(&mut lib, name))?;
-        let load_fn = |name: &std::ffi::CStr| unsafe {
-            mem::transmute(static_fn.get_instance_proc_addr(vk::Instance::null(), name.as_ptr()))
+impl Entry {
+    /// Load default Vulkan library for the current platform
+    ///
+    /// Prefer this over [`linked`](Self::linked) when your application can gracefully handle
+    /// environments that lack Vulkan support, and when the build environment might not have Vulkan
+    /// development packages installed (e.g. the Vulkan SDK, or Ubuntu's `libvulkan-dev`).
+    ///
+    /// # Safety
+    ///
+    /// `dlopen`ing native libraries is inherently unsafe. The safety guidelines
+    /// for [`Library::new()`] and [`Library::get()`] apply here.
+    ///
+    /// No Vulkan functions loaded directly or indirectly from this [`Entry`]
+    /// may be called after it is [dropped][drop()].
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use ash::{vk, Entry};
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let entry = unsafe { Entry::load()? };
+    /// let app_info = vk::ApplicationInfo {
+    ///     api_version: vk::make_api_version(0, 1, 0, 0),
+    ///     ..Default::default()
+    /// };
+    /// let create_info = vk::InstanceCreateInfo {
+    ///     p_application_info: &app_info,
+    ///     ..Default::default()
+    /// };
+    /// let instance = unsafe { entry.create_instance(&create_info, None)? };
+    /// # Ok(()) }
+    /// ```
+    #[cfg(feature = "loaded")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))]
+    pub unsafe fn load() -> Result<Self, LoadingError> {
+        #[cfg(windows)]
+        const LIB_PATH: &str = "vulkan-1.dll";
+
+        #[cfg(all(
+            unix,
+            not(any(target_os = "macos", target_os = "ios", target_os = "android"))
+        ))]
+        const LIB_PATH: &str = "libvulkan.so.1";
+
+        #[cfg(target_os = "android")]
+        const LIB_PATH: &str = "libvulkan.so";
+
+        #[cfg(any(target_os = "macos", target_os = "ios"))]
+        const LIB_PATH: &str = "libvulkan.dylib";
+
+        Self::load_from(LIB_PATH)
+    }
+
+    /// Load entry points from a Vulkan loader linked at compile time
+    ///
+    /// Compared to [`load`](Self::load), this is infallible, but requires that the build
+    /// environment have Vulkan development packages installed (e.g. the Vulkan SDK, or Ubuntu's
+    /// `libvulkan-dev`), and prevents the resulting binary from starting in environments that do not
+    /// support Vulkan.
+    ///
+    /// Note that instance/device functions are still fetched via `vkGetInstanceProcAddr` and
+    /// `vkGetDeviceProcAddr` for maximum performance.
+    ///
+    /// Any Vulkan function acquired directly or indirectly from this [`Entry`] may be called after it
+    /// is [dropped][drop()].
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use ash::{vk, Entry};
+    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /// let entry = Entry::linked();
+    /// let app_info = vk::ApplicationInfo {
+    ///     api_version: vk::make_api_version(0, 1, 0, 0),
+    ///     ..Default::default()
+    /// };
+    /// let create_info = vk::InstanceCreateInfo {
+    ///     p_application_info: &app_info,
+    ///     ..Default::default()
+    /// };
+    /// let instance = unsafe { entry.create_instance(&create_info, None)? };
+    /// # Ok(()) }
+    /// ```
+    #[cfg(feature = "linked")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "linked")))]
+    pub fn linked() -> Self {
+        // Sound because we're linking to Vulkan, which provides a vkGetInstanceProcAddr that has
+        // defined behavior in this use.
+        unsafe {
+            Self::from_static_fn(vk::StaticFn {
+                get_instance_proc_addr: vkGetInstanceProcAddr,
+            })
+        }
+    }
+
+    /// Load Vulkan library at `path`
+    ///
+    /// # Safety
+    ///
+    /// `dlopen`ing native libraries is inherently unsafe. The safety guidelines
+    /// for [`Library::new()`] and [`Library::get()`] apply here.
+    ///
+    /// No Vulkan functions loaded directly or indirectly from this [`Entry`]
+    /// may be called after it is [dropped][drop()].
+    #[cfg(feature = "loaded")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))]
+    pub unsafe fn load_from(path: impl AsRef<OsStr>) -> Result<Self, LoadingError> {
+        let lib = Library::new(path)
+            .map_err(LoadingError::LibraryLoadFailure)
+            .map(Arc::new)?;
+
+        let static_fn = vk::StaticFn::load_checked(|name| {
+            lib.get(name.to_bytes_with_nul())
+                .map(|symbol| *symbol)
+                .unwrap_or(ptr::null_mut())
+        })?;
+
+        Ok(Self {
+            _lib_guard: Some(lib),
+            ..Self::from_static_fn(static_fn)
+        })
+    }
+
+    /// Load entry points based on an already-loaded [`vk::StaticFn`]
+    ///
+    /// # Safety
+    ///
+    /// `static_fn` must contain valid function pointers that comply with the semantics specified
+    /// by Vulkan 1.0, which must remain valid for at least the lifetime of the returned [`Entry`].
+    pub unsafe fn from_static_fn(static_fn: vk::StaticFn) -> Self {
+        let load_fn = |name: &std::ffi::CStr| {
+            mem::transmute((static_fn.get_instance_proc_addr)(
+                vk::Instance::null(),
+                name.as_ptr(),
+            ))
         };
         let entry_fn_1_0 = vk::EntryFnV1_0::load(load_fn);
         let entry_fn_1_1 = vk::EntryFnV1_1::load(load_fn);
         let entry_fn_1_2 = vk::EntryFnV1_2::load(load_fn);
+        let entry_fn_1_3 = vk::EntryFnV1_3::load(load_fn);
 
-        Ok(EntryCustom {
+        Self {
             static_fn,
             entry_fn_1_0,
             entry_fn_1_1,
             entry_fn_1_2,
-            lib,
-        })
+            entry_fn_1_3,
+            #[cfg(feature = "loaded")]
+            _lib_guard: None,
+        }
     }
 
+    #[inline]
     pub fn fp_v1_0(&self) -> &vk::EntryFnV1_0 {
         &self.entry_fn_1_0
     }
 
+    #[inline]
     pub fn static_fn(&self) -> &vk::StaticFn {
         &self.static_fn
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceVersion.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceVersion.html>
+    ///
+    /// # Example
+    ///
     /// ```no_run
     /// # use ash::{Entry, vk};
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let entry = unsafe { Entry::new() }?;
+    /// let entry = Entry::linked();
     /// match entry.try_enumerate_instance_version()? {
     ///     // Vulkan 1.1+
     ///     Some(version) => {
@@ -78,15 +211,18 @@ impl<L> EntryCustom<L> {
     /// }
     /// # Ok(()) }
     /// ```
+    #[inline]
     pub fn try_enumerate_instance_version(&self) -> VkResult<Option<u32>> {
         unsafe {
             let mut api_version = 0;
             let enumerate_instance_version: Option<vk::PFN_vkEnumerateInstanceVersion> = {
-                let name = b"vkEnumerateInstanceVersion\0".as_ptr() as *const _;
-                mem::transmute(
-                    self.static_fn
-                        .get_instance_proc_addr(vk::Instance::null(), name),
-                )
+                let name = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkEnumerateInstanceVersion\0",
+                );
+                mem::transmute((self.static_fn.get_instance_proc_addr)(
+                    vk::Instance::null(),
+                    name.as_ptr(),
+                ))
             };
             if let Some(enumerate_instance_version) = enumerate_instance_version {
                 (enumerate_instance_version)(&mut api_version)
@@ -97,77 +233,87 @@ impl<L> EntryCustom<L> {
         }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateInstance.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateInstance.html>
     ///
     /// # Safety
-    /// In order for the created [`Instance`] to be valid for the duration of its
-    /// usage, the [`Entry`](Self) this was called on must be dropped later than the
-    /// resulting [`Instance`].
+    ///
+    /// The resulting [`Instance`] and any function-pointer objects (e.g. [`Device`][crate::Device]
+    /// and [extensions][crate::extensions]) loaded from it may not be used after this [`Entry`]
+    /// object is dropped, unless it was crated using [`Entry::linked()`].
+    ///
+    /// [`Instance`] does _not_ implement [drop][drop()] semantics and can only be destroyed via
+    /// [`destroy_instance()`][Instance::destroy_instance()].
+    #[inline]
     pub unsafe fn create_instance(
         &self,
         create_info: &vk::InstanceCreateInfo,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
-    ) -> Result<Instance, InstanceError> {
+    ) -> VkResult<Instance> {
         let mut instance = mem::zeroed();
-        self.entry_fn_1_0
-            .create_instance(
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut instance,
-            )
-            .result()
-            .map_err(InstanceError::VkError)?;
+        (self.entry_fn_1_0.create_instance)(
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut instance,
+        )
+        .result()?;
         Ok(Instance::load(&self.static_fn, instance))
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceLayerProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceLayerProperties.html>
+    #[inline]
     pub fn enumerate_instance_layer_properties(&self) -> VkResult<Vec<vk::LayerProperties>> {
         unsafe {
             read_into_uninitialized_vector(|count, data| {
-                self.entry_fn_1_0
-                    .enumerate_instance_layer_properties(count, data)
+                (self.entry_fn_1_0.enumerate_instance_layer_properties)(count, data)
             })
         }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceExtensionProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceExtensionProperties.html>
+    #[inline]
     pub fn enumerate_instance_extension_properties(
         &self,
+        layer_name: Option<&CStr>,
     ) -> VkResult<Vec<vk::ExtensionProperties>> {
         unsafe {
             read_into_uninitialized_vector(|count, data| {
-                self.entry_fn_1_0
-                    .enumerate_instance_extension_properties(ptr::null(), count, data)
+                (self.entry_fn_1_0.enumerate_instance_extension_properties)(
+                    layer_name.map_or(ptr::null(), |str| str.as_ptr()),
+                    count,
+                    data,
+                )
             })
         }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetInstanceProcAddr.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetInstanceProcAddr.html>
+    #[inline]
     pub unsafe fn get_instance_proc_addr(
         &self,
         instance: vk::Instance,
         p_name: *const c_char,
     ) -> vk::PFN_vkVoidFunction {
-        self.static_fn.get_instance_proc_addr(instance, p_name)
+        (self.static_fn.get_instance_proc_addr)(instance, p_name)
     }
 }
 
 /// Vulkan core 1.1
 #[allow(non_camel_case_types)]
-impl<L> EntryCustom<L> {
+impl Entry {
+    #[inline]
     pub fn fp_v1_1(&self) -> &vk::EntryFnV1_1 {
         &self.entry_fn_1_1
     }
 
-    #[deprecated = "This function is unavailable and therefore panics on Vulkan 1.0, please use `try_enumerate_instance_version` instead"]
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceVersion.html>"]
+    #[deprecated = "This function is unavailable and therefore panics on Vulkan 1.0, please use `try_enumerate_instance_version()` instead"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceVersion.html>
     ///
-    /// Please use [`Self::try_enumerate_instance_version`] instead.
+    /// Please use [`try_enumerate_instance_version()`][Self::try_enumerate_instance_version()] instead.
+    #[inline]
     pub fn enumerate_instance_version(&self) -> VkResult<u32> {
         unsafe {
             let mut api_version = 0;
-            self.entry_fn_1_1
-                .enumerate_instance_version(&mut api_version)
+            (self.entry_fn_1_1.enumerate_instance_version)(&mut api_version)
                 .result_with_success(api_version)
         }
     }
@@ -175,29 +321,31 @@ impl<L> EntryCustom<L> {
 
 /// Vulkan core 1.2
 #[allow(non_camel_case_types)]
-impl<L> EntryCustom<L> {
+impl Entry {
+    #[inline]
     pub fn fp_v1_2(&self) -> &vk::EntryFnV1_2 {
         &self.entry_fn_1_2
     }
 }
 
-#[derive(Clone, Debug)]
-pub enum InstanceError {
-    LoadError(Vec<&'static str>),
-    VkError(vk::Result),
+/// Vulkan core 1.3
+#[allow(non_camel_case_types)]
+impl Entry {
+    #[inline]
+    pub fn fp_v1_3(&self) -> &vk::EntryFnV1_3 {
+        &self.entry_fn_1_3
+    }
 }
 
-impl fmt::Display for InstanceError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            InstanceError::LoadError(e) => write!(f, "{}", e.join("; ")),
-            InstanceError::VkError(e) => write!(f, "{}", e),
-        }
+#[cfg(feature = "linked")]
+#[cfg_attr(docsrs, doc(cfg(feature = "linked")))]
+impl Default for Entry {
+    #[inline]
+    fn default() -> Self {
+        Self::linked()
     }
 }
 
-impl Error for InstanceError {}
-
 impl vk::StaticFn {
     pub fn load_checked<F>(mut _f: F) -> Result<Self, MissingEntryPoint>
     where
@@ -206,7 +354,7 @@ impl vk::StaticFn {
         // TODO: Make this a &'static CStr once CStr::from_bytes_with_nul_unchecked is const
         static ENTRY_POINT: &[u8] = b"vkGetInstanceProcAddr\0";
 
-        Ok(vk::StaticFn {
+        Ok(Self {
             get_instance_proc_addr: unsafe {
                 let cname = CStr::from_bytes_with_nul_unchecked(ENTRY_POINT);
                 let val = _f(cname);
@@ -228,3 +376,50 @@ impl std::fmt::Display for MissingEntryPoint {
     }
 }
 impl std::error::Error for MissingEntryPoint {}
+
+#[cfg(feature = "linked")]
+extern "system" {
+    fn vkGetInstanceProcAddr(instance: vk::Instance, name: *const c_char)
+        -> vk::PFN_vkVoidFunction;
+}
+
+#[cfg(feature = "loaded")]
+mod loaded {
+    use std::error::Error;
+    use std::fmt;
+
+    use super::*;
+
+    #[derive(Debug)]
+    #[cfg_attr(docsrs, doc(cfg(feature = "loaded")))]
+    pub enum LoadingError {
+        LibraryLoadFailure(libloading::Error),
+        MissingEntryPoint(MissingEntryPoint),
+    }
+
+    impl fmt::Display for LoadingError {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            match self {
+                Self::LibraryLoadFailure(err) => fmt::Display::fmt(err, f),
+                Self::MissingEntryPoint(err) => fmt::Display::fmt(err, f),
+            }
+        }
+    }
+
+    impl Error for LoadingError {
+        fn source(&self) -> Option<&(dyn Error + 'static)> {
+            Some(match self {
+                Self::LibraryLoadFailure(err) => err,
+                Self::MissingEntryPoint(err) => err,
+            })
+        }
+    }
+
+    impl From<MissingEntryPoint> for LoadingError {
+        fn from(err: MissingEntryPoint) -> Self {
+            Self::MissingEntryPoint(err)
+        }
+    }
+}
+#[cfg(feature = "loaded")]
+pub use self::loaded::*;
diff --git a/src/entry_libloading.rs b/src/entry_libloading.rs
deleted file mode 100644
index 3e9386a..0000000
--- a/src/entry_libloading.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use crate::entry::EntryCustom;
-use crate::entry::MissingEntryPoint;
-use libloading::Library;
-use std::error::Error;
-use std::ffi::OsStr;
-use std::fmt;
-use std::ptr;
-use std::sync::Arc;
-
-#[cfg(windows)]
-const LIB_PATH: &str = "vulkan-1.dll";
-
-#[cfg(all(
-    unix,
-    not(any(target_os = "macos", target_os = "ios", target_os = "android"))
-))]
-const LIB_PATH: &str = "libvulkan.so.1";
-
-#[cfg(target_os = "android")]
-const LIB_PATH: &str = "libvulkan.so";
-
-#[cfg(any(target_os = "macos", target_os = "ios"))]
-const LIB_PATH: &str = "libvulkan.dylib";
-
-#[derive(Debug)]
-pub enum LoadingError {
-    LibraryLoadFailure(libloading::Error),
-    MissingEntryPoint(MissingEntryPoint),
-}
-
-impl fmt::Display for LoadingError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            LoadingError::LibraryLoadFailure(err) => fmt::Display::fmt(err, f),
-            LoadingError::MissingEntryPoint(err) => fmt::Display::fmt(err, f),
-        }
-    }
-}
-
-impl Error for LoadingError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        Some(match self {
-            LoadingError::LibraryLoadFailure(err) => err,
-            LoadingError::MissingEntryPoint(err) => err,
-        })
-    }
-}
-
-impl From<MissingEntryPoint> for LoadingError {
-    fn from(err: MissingEntryPoint) -> Self {
-        LoadingError::MissingEntryPoint(err)
-    }
-}
-
-/// Default function loader
-pub type Entry = EntryCustom<Arc<Library>>;
-
-impl Entry {
-    /// Load default Vulkan library for the current platform
-    ///
-    /// # Safety
-    /// `dlopen`ing native libraries is inherently unsafe. The safety guidelines
-    /// for [`Library::new`] and [`Library::get`] apply here.
-    ///
-    /// ```no_run
-    /// use ash::{vk, Entry};
-    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let entry = unsafe { Entry::new() }?;
-    /// let app_info = vk::ApplicationInfo {
-    ///     api_version: vk::make_api_version(0, 1, 0, 0),
-    ///     ..Default::default()
-    /// };
-    /// let create_info = vk::InstanceCreateInfo {
-    ///     p_application_info: &app_info,
-    ///     ..Default::default()
-    /// };
-    /// let instance = unsafe { entry.create_instance(&create_info, None)? };
-    /// # Ok(()) }
-    /// ```
-    pub unsafe fn new() -> Result<Entry, LoadingError> {
-        Self::with_library(LIB_PATH)
-    }
-
-    /// Load Vulkan library at `path`
-    ///
-    /// # Safety
-    /// `dlopen`ing native libraries is inherently unsafe. The safety guidelines
-    /// for [`Library::new`] and [`Library::get`] apply here.
-    pub unsafe fn with_library(path: impl AsRef<OsStr>) -> Result<Entry, LoadingError> {
-        let lib = Library::new(path)
-            .map_err(LoadingError::LibraryLoadFailure)
-            .map(Arc::new)?;
-
-        Ok(Self::new_custom(lib, |vk_lib, name| {
-            vk_lib
-                .get(name.to_bytes_with_nul())
-                .map(|symbol| *symbol)
-                .unwrap_or(ptr::null_mut())
-        })?)
-    }
-}
diff --git a/src/extensions/experimental/amd.rs b/src/extensions/experimental/amd.rs
index 648f28f..35b4289 100644
--- a/src/extensions/experimental/amd.rs
+++ b/src/extensions/experimental/amd.rs
@@ -25,7 +25,10 @@
  *
  **********************************************************************************************************************/
 
+#[cfg(feature = "debug")]
+use crate::prelude::debug_flags;
 use crate::vk::*;
+
 use std::fmt;
 use std::os::raw::*;
 
@@ -34,15 +37,8 @@ use std::os::raw::*;
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct GpaSqShaderStageFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(
-    GpaSqShaderStageFlags,
-    0b1111111111111111111111111111111,
-    Flags
-);
-// ignore clippy::use_self false positives
-// changing GpaSqShaderStageFlags::PS.0 to Self::PS.0 as suggested by clippy generates:
-// error[E0401]: can't use generic parameters from outer function
-#[allow(clippy::use_self)]
+vk_bitflags_wrapped!(GpaSqShaderStageFlags, Flags);
+#[cfg(feature = "debug")]
 impl fmt::Debug for GpaSqShaderStageFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
@@ -75,7 +71,8 @@ impl StructureType {
     pub const GPA_DEVICE_CLOCK_MODE_INFO_AMD: Self = Self(1000133004);
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 #[repr(transparent)]
 pub struct GpaDeviceClockModeAmd(pub(crate) i32);
 impl GpaDeviceClockModeAmd {
@@ -95,7 +92,8 @@ impl GpaDeviceClockModeAmd {
     pub const PEAK: Self = Self(5);
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 #[repr(transparent)]
 pub struct GpaPerfBlockAmd(pub(crate) i32);
 impl GpaPerfBlockAmd {
@@ -141,7 +139,8 @@ impl GpaPerfBlockAmd {
     pub const RMI: Self = Self(31);
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 #[repr(transparent)]
 pub struct GpaSampleTypeAmd(pub(crate) i32);
 impl GpaSampleTypeAmd {
@@ -161,7 +160,8 @@ impl GpaSampleTypeAmd {
 handle_nondispatchable!(GpaSessionAmd, UNKNOWN);
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct GpaSessionCreateInfoAmd {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -169,7 +169,8 @@ pub struct GpaSessionCreateInfoAmd {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct GpaPerfBlockPropertiesAmd {
     pub block_type: GpaPerfBlockAmd,
     pub flags: Flags,
@@ -181,7 +182,8 @@ pub struct GpaPerfBlockPropertiesAmd {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct PhysicalDeviceGpaFeaturesAmd {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -192,7 +194,8 @@ pub struct PhysicalDeviceGpaFeaturesAmd {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct PhysicalDeviceGpaPropertiesAmd {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -237,11 +240,16 @@ impl<'a> ::std::ops::Deref for PhysicalDeviceGpaPropertiesAmdBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceGpaPropertiesAmdBuilder<'a> {
-    pub fn next<T>(mut self, next: &'a mut T) -> PhysicalDeviceGpaPropertiesAmdBuilder<'a>
+    pub fn push_next<T>(mut self, next: &'a mut T) -> PhysicalDeviceGpaPropertiesAmdBuilder<'a>
     where
         T: ExtendsPhysicalDeviceGpaPropertiesAmd,
     {
-        self.inner.p_next = next as *mut T as *mut c_void;
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
         self
     }
     pub fn build(self) -> PhysicalDeviceGpaPropertiesAmd {
@@ -250,7 +258,8 @@ impl<'a> PhysicalDeviceGpaPropertiesAmdBuilder<'a> {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct GpaPerfCounterAmd {
     pub block_type: GpaPerfBlockAmd,
     pub block_instance: u32,
@@ -258,7 +267,8 @@ pub struct GpaPerfCounterAmd {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct GpaSampleBeginInfoAmd {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -279,7 +289,8 @@ pub struct GpaSampleBeginInfoAmd {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct GpaDeviceClockModeInfoAmd {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -403,9 +414,9 @@ impl AmdGpaInterfaceFn {
                         stringify!(create_gpa_session_amd)
                     ))
                 }
-                let raw_name = stringify!(vkCreateGpaSessionAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateGpaSessionAMD\0");
+                let val = _f(cname);
                 if val.is_null() {
                     create_gpa_session_amd
                 } else {
@@ -423,9 +434,9 @@ impl AmdGpaInterfaceFn {
                         stringify!(destroy_gpa_session_amd)
                     ))
                 }
-                let raw_name = stringify!(vkDestroyGpaSessionAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyGpaSessionAMD\0");
+                let val = _f(cname);
                 if val.is_null() {
                     destroy_gpa_session_amd
                 } else {
@@ -442,9 +453,10 @@ impl AmdGpaInterfaceFn {
                         stringify!(set_gpa_device_clock_mode_amd)
                     ))
                 }
-                let raw_name = stringify!(vkSetGpaDeviceClockModeAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkSetGpaDeviceClockModeAMD\0",
+                );
+                let val = _f(cname);
                 if val.is_null() {
                     set_gpa_device_clock_mode_amd
                 } else {
@@ -461,9 +473,9 @@ impl AmdGpaInterfaceFn {
                         stringify!(cmd_begin_gpa_session_amd)
                     ))
                 }
-                let raw_name = stringify!(vkCmdBeginGpaSessionAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginGpaSessionAMD\0");
+                let val = _f(cname);
                 if val.is_null() {
                     cmd_begin_gpa_session_amd
                 } else {
@@ -480,9 +492,9 @@ impl AmdGpaInterfaceFn {
                         stringify!(cmd_end_gpa_session_amd)
                     ))
                 }
-                let raw_name = stringify!(vkCmdEndGpaSessionAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSessionAMD\0");
+                let val = _f(cname);
                 if val.is_null() {
                     cmd_end_gpa_session_amd
                 } else {
@@ -501,9 +513,9 @@ impl AmdGpaInterfaceFn {
                         stringify!(cmd_begin_gpa_sample_amd)
                     ))
                 }
-                let raw_name = stringify!(vkCmdBeginGpaSampleAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginGpaSampleAMD\0");
+                let val = _f(cname);
                 if val.is_null() {
                     cmd_begin_gpa_sample_amd
                 } else {
@@ -521,9 +533,9 @@ impl AmdGpaInterfaceFn {
                         stringify!(cmd_end_gpa_sample_amd)
                     ))
                 }
-                let raw_name = stringify!(vkCmdEndGpaSampleAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSampleAMD\0");
+                let val = _f(cname);
                 if val.is_null() {
                     cmd_end_gpa_sample_amd
                 } else {
@@ -540,9 +552,9 @@ impl AmdGpaInterfaceFn {
                         stringify!(get_gpa_session_status_amd)
                     ))
                 }
-                let raw_name = stringify!(vkGetGpaSessionStatusAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetGpaSessionStatusAMD\0");
+                let val = _f(cname);
                 if val.is_null() {
                     get_gpa_session_status_amd
                 } else {
@@ -562,9 +574,9 @@ impl AmdGpaInterfaceFn {
                         stringify!(get_gpa_session_results_amd)
                     ))
                 }
-                let raw_name = stringify!(vkGetGpaSessionResultsAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetGpaSessionResultsAMD\0");
+                let val = _f(cname);
                 if val.is_null() {
                     get_gpa_session_results_amd
                 } else {
@@ -581,9 +593,9 @@ impl AmdGpaInterfaceFn {
                         stringify!(reset_gpa_session_amd)
                     ))
                 }
-                let raw_name = stringify!(vkCmdEndGpaSampleAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndGpaSampleAMD\0");
+                let val = _f(cname);
                 if val.is_null() {
                     reset_gpa_session_amd
                 } else {
@@ -600,9 +612,10 @@ impl AmdGpaInterfaceFn {
                         stringify!(cmd_copy_gpa_session_results_amd)
                     ))
                 }
-                let raw_name = stringify!(vkCmdCopyGpaSessionResultsAMD);
-                let cname = ::std::ffi::CString::new(raw_name).unwrap();
-                let val = _f(&cname);
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdCopyGpaSessionResultsAMD\0",
+                );
+                let val = _f(cname);
                 if val.is_null() {
                     cmd_copy_gpa_session_results_amd
                 } else {
@@ -638,7 +651,8 @@ impl StructureType {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct PhysicalDeviceWaveLimitPropertiesAmd {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -685,10 +699,10 @@ impl<'a> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> {
         T: ExtendsPhysicalDeviceWaveLimitPropertiesAmd,
     {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -698,7 +712,8 @@ impl<'a> PhysicalDeviceWaveLimitPropertiesAmdBuilder<'a> {
 }
 
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "debug", derive(Debug))]
 pub struct PipelineShaderStageCreateInfoWaveLimitAmd {
     pub s_type: StructureType,
     pub p_next: *const c_void,
diff --git a/src/extensions/ext/acquire_drm_display.rs b/src/extensions/ext/acquire_drm_display.rs
new file mode 100644
index 0000000..8c80e50
--- /dev/null
+++ b/src/extensions/ext/acquire_drm_display.rs
@@ -0,0 +1,55 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_acquire_drm_display.html>
+#[derive(Clone)]
+pub struct AcquireDrmDisplay {
+    fp: vk::ExtAcquireDrmDisplayFn,
+}
+
+impl AcquireDrmDisplay {
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::ExtAcquireDrmDisplayFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireDrmDisplayEXT.html>
+    #[inline]
+    pub unsafe fn acquire_drm_display(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        drm_fd: i32,
+        display: vk::DisplayKHR,
+    ) -> VkResult<()> {
+        (self.fp.acquire_drm_display_ext)(physical_device, drm_fd, display).result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDrmDisplayEXT.html>
+    #[inline]
+    pub unsafe fn get_drm_display(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        drm_fd: i32,
+        connector_id: u32,
+    ) -> VkResult<vk::DisplayKHR> {
+        let mut display = mem::MaybeUninit::uninit();
+        (self.fp.get_drm_display_ext)(physical_device, drm_fd, connector_id, display.as_mut_ptr())
+            .assume_init_on_success(display)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtAcquireDrmDisplayFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtAcquireDrmDisplayFn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/ext/buffer_device_address.rs b/src/extensions/ext/buffer_device_address.rs
index ecb03af..a1d304e 100644
--- a/src/extensions/ext/buffer_device_address.rs
+++ b/src/extensions/ext/buffer_device_address.rs
@@ -6,36 +6,38 @@ use std::mem;
 #[derive(Clone)]
 pub struct BufferDeviceAddress {
     handle: vk::Device,
-    fns: vk::ExtBufferDeviceAddressFn,
+    fp: vk::ExtBufferDeviceAddressFn,
 }
 
 impl BufferDeviceAddress {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let fns = vk::ExtBufferDeviceAddressFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::ExtBufferDeviceAddressFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            fns,
-        }
+        Self { handle, fp }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferDeviceAddressEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferDeviceAddressEXT.html>
+    #[inline]
     pub unsafe fn get_buffer_device_address(
         &self,
         info: &vk::BufferDeviceAddressInfoEXT,
     ) -> vk::DeviceAddress {
-        self.fns.get_buffer_device_address_ext(self.handle, info)
+        (self.fp.get_buffer_device_address_ext)(self.handle, info)
     }
 
-    pub fn name() -> &'static CStr {
+    #[inline]
+    pub const fn name() -> &'static CStr {
         vk::ExtBufferDeviceAddressFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::ExtBufferDeviceAddressFn {
-        &self.fns
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/ext/calibrated_timestamps.rs b/src/extensions/ext/calibrated_timestamps.rs
new file mode 100644
index 0000000..e102fca
--- /dev/null
+++ b/src/extensions/ext/calibrated_timestamps.rs
@@ -0,0 +1,72 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+#[derive(Clone)]
+pub struct CalibratedTimestamps {
+    handle: vk::Instance,
+    fp: vk::ExtCalibratedTimestampsFn,
+}
+
+impl CalibratedTimestamps {
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::ExtCalibratedTimestampsFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html>
+    #[inline]
+    pub unsafe fn get_physical_device_calibrateable_time_domains(
+        &self,
+        physical_device: vk::PhysicalDevice,
+    ) -> VkResult<Vec<vk::TimeDomainEXT>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_physical_device_calibrateable_time_domains_ext)(
+                physical_device,
+                count,
+                data,
+            )
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetCalibratedTimestampsEXT.html>
+    ///
+    /// Returns a tuple containing `(timestamps, max_deviation)`
+    #[inline]
+    pub unsafe fn get_calibrated_timestamps(
+        &self,
+        device: vk::Device,
+        info: &[vk::CalibratedTimestampInfoEXT],
+    ) -> VkResult<(Vec<u64>, Vec<u64>)> {
+        let mut timestamps = vec![0u64; info.len()];
+        let mut max_deviation = vec![0u64; info.len()];
+        (self.fp.get_calibrated_timestamps_ext)(
+            device,
+            info.len() as u32,
+            info.as_ptr(),
+            timestamps.as_mut_ptr(),
+            max_deviation.as_mut_ptr(),
+        )
+        .result_with_success((timestamps, max_deviation))
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtCalibratedTimestampsFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtCalibratedTimestampsFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn instance(&self) -> vk::Instance {
+        self.handle
+    }
+}
diff --git a/src/extensions/ext/debug_marker.rs b/src/extensions/ext/debug_marker.rs
index 5e86083..1c21a47 100755
--- a/src/extensions/ext/debug_marker.rs
+++ b/src/extensions/ext/debug_marker.rs
@@ -6,59 +6,66 @@ use std::mem;
 
 #[derive(Clone)]
 pub struct DebugMarker {
-    debug_marker_fn: vk::ExtDebugMarkerFn,
+    handle: vk::Device,
+    fp: vk::ExtDebugMarkerFn,
 }
 
 impl DebugMarker {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let debug_marker_fn = vk::ExtDebugMarkerFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::ExtDebugMarkerFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self { debug_marker_fn }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::ExtDebugMarkerFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDebugMarkerSetObjectNameEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDebugMarkerSetObjectNameEXT.html>
+    #[inline]
     pub unsafe fn debug_marker_set_object_name(
         &self,
-        device: vk::Device,
         name_info: &vk::DebugMarkerObjectNameInfoEXT,
     ) -> VkResult<()> {
-        self.debug_marker_fn
-            .debug_marker_set_object_name_ext(device, name_info)
-            .into()
+        (self.fp.debug_marker_set_object_name_ext)(self.handle, name_info).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDebugMarkerBeginEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDebugMarkerBeginEXT.html>
+    #[inline]
     pub unsafe fn cmd_debug_marker_begin(
         &self,
         command_buffer: vk::CommandBuffer,
         marker_info: &vk::DebugMarkerMarkerInfoEXT,
     ) {
-        self.debug_marker_fn
-            .cmd_debug_marker_begin_ext(command_buffer, marker_info);
+        (self.fp.cmd_debug_marker_begin_ext)(command_buffer, marker_info);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDebugMarkerEndEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDebugMarkerEndEXT.html>
+    #[inline]
     pub unsafe fn cmd_debug_marker_end(&self, command_buffer: vk::CommandBuffer) {
-        self.debug_marker_fn
-            .cmd_debug_marker_end_ext(command_buffer);
+        (self.fp.cmd_debug_marker_end_ext)(command_buffer);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDebugMarkerInsertEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDebugMarkerInsertEXT.html>
+    #[inline]
     pub unsafe fn cmd_debug_marker_insert(
         &self,
         command_buffer: vk::CommandBuffer,
         marker_info: &vk::DebugMarkerMarkerInfoEXT,
     ) {
-        self.debug_marker_fn
-            .cmd_debug_marker_insert_ext(command_buffer, marker_info);
+        (self.fp.cmd_debug_marker_insert_ext)(command_buffer, marker_info);
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtDebugMarkerFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::ExtDebugMarkerFn {
-        &self.debug_marker_fn
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
     }
 }
diff --git a/src/extensions/ext/debug_report.rs b/src/extensions/ext/debug_report.rs
index 3400566..625ebf4 100755
--- a/src/extensions/ext/debug_report.rs
+++ b/src/extensions/ext/debug_report.rs
@@ -1,65 +1,67 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct DebugReport {
     handle: vk::Instance,
-    debug_report_fn: vk::ExtDebugReportFn,
+    fp: vk::ExtDebugReportFn,
 }
 
 impl DebugReport {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let debug_report_fn = vk::ExtDebugReportFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::ExtDebugReportFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            debug_report_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::ExtDebugReportFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDebugReportCallbackEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDebugReportCallbackEXT.html>
+    #[inline]
     pub unsafe fn destroy_debug_report_callback(
         &self,
         debug: vk::DebugReportCallbackEXT,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.debug_report_fn.destroy_debug_report_callback_ext(
+        (self.fp.destroy_debug_report_callback_ext)(
             self.handle,
             debug,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDebugReportCallbackEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDebugReportCallbackEXT.html>
+    #[inline]
     pub unsafe fn create_debug_report_callback(
         &self,
         create_info: &vk::DebugReportCallbackCreateInfoEXT,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DebugReportCallbackEXT> {
         let mut debug_cb = mem::zeroed();
-        self.debug_report_fn
-            .create_debug_report_callback_ext(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut debug_cb,
-            )
-            .result_with_success(debug_cb)
+        (self.fp.create_debug_report_callback_ext)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut debug_cb,
+        )
+        .result_with_success(debug_cb)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtDebugReportFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::ExtDebugReportFn {
-        &self.debug_report_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/ext/debug_utils.rs b/src/extensions/ext/debug_utils.rs
index 69ce2e9..46d9176 100755
--- a/src/extensions/ext/debug_utils.rs
+++ b/src/extensions/ext/debug_utils.rs
@@ -1,153 +1,172 @@
 use crate::prelude::*;
 use crate::{vk, RawPtr};
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct DebugUtils {
     handle: vk::Instance,
-    debug_utils_fn: vk::ExtDebugUtilsFn,
+    fp: vk::ExtDebugUtilsFn,
 }
 
 impl DebugUtils {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let debug_utils_fn = vk::ExtDebugUtilsFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::ExtDebugUtilsFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            debug_utils_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::ExtDebugUtilsFn::name()
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetDebugUtilsObjectNameEXT.html>
+    #[deprecated = "Backwards-compatible alias containing a typo, use `set_debug_utils_object_name()` instead"]
+    #[inline]
+    pub unsafe fn debug_utils_set_object_name(
+        &self,
+        device: vk::Device,
+        name_info: &vk::DebugUtilsObjectNameInfoEXT,
+    ) -> VkResult<()> {
+        self.set_debug_utils_object_name(device, name_info)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetDebugUtilsObjectNameEXT.html>"]
-    pub unsafe fn debug_utils_set_object_name(
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetDebugUtilsObjectNameEXT.html>
+    #[inline]
+    pub unsafe fn set_debug_utils_object_name(
         &self,
         device: vk::Device,
         name_info: &vk::DebugUtilsObjectNameInfoEXT,
     ) -> VkResult<()> {
-        self.debug_utils_fn
-            .set_debug_utils_object_name_ext(device, name_info)
-            .into()
+        (self.fp.set_debug_utils_object_name_ext)(device, name_info).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetDebugUtilsObjectTagEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetDebugUtilsObjectTagEXT.html>
+    #[deprecated = "Backwards-compatible alias containing a typo, use `set_debug_utils_object_tag()` instead"]
+    #[inline]
     pub unsafe fn debug_utils_set_object_tag(
         &self,
         device: vk::Device,
         tag_info: &vk::DebugUtilsObjectTagInfoEXT,
     ) -> VkResult<()> {
-        self.debug_utils_fn
-            .set_debug_utils_object_tag_ext(device, tag_info)
-            .into()
+        self.set_debug_utils_object_tag(device, tag_info)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetDebugUtilsObjectTagEXT.html>
+    #[inline]
+    pub unsafe fn set_debug_utils_object_tag(
+        &self,
+        device: vk::Device,
+        tag_info: &vk::DebugUtilsObjectTagInfoEXT,
+    ) -> VkResult<()> {
+        (self.fp.set_debug_utils_object_tag_ext)(device, tag_info).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginDebugUtilsLabelEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginDebugUtilsLabelEXT.html>
+    #[inline]
     pub unsafe fn cmd_begin_debug_utils_label(
         &self,
         command_buffer: vk::CommandBuffer,
         label: &vk::DebugUtilsLabelEXT,
     ) {
-        self.debug_utils_fn
-            .cmd_begin_debug_utils_label_ext(command_buffer, label);
+        (self.fp.cmd_begin_debug_utils_label_ext)(command_buffer, label);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndDebugUtilsLabelEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndDebugUtilsLabelEXT.html>
+    #[inline]
     pub unsafe fn cmd_end_debug_utils_label(&self, command_buffer: vk::CommandBuffer) {
-        self.debug_utils_fn
-            .cmd_end_debug_utils_label_ext(command_buffer);
+        (self.fp.cmd_end_debug_utils_label_ext)(command_buffer);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdInsertDebugUtilsLabelEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdInsertDebugUtilsLabelEXT.html>
+    #[inline]
     pub unsafe fn cmd_insert_debug_utils_label(
         &self,
         command_buffer: vk::CommandBuffer,
         label: &vk::DebugUtilsLabelEXT,
     ) {
-        self.debug_utils_fn
-            .cmd_insert_debug_utils_label_ext(command_buffer, label);
+        (self.fp.cmd_insert_debug_utils_label_ext)(command_buffer, label);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueBeginDebugUtilsLabelEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueBeginDebugUtilsLabelEXT.html>
+    #[inline]
     pub unsafe fn queue_begin_debug_utils_label(
         &self,
         queue: vk::Queue,
         label: &vk::DebugUtilsLabelEXT,
     ) {
-        self.debug_utils_fn
-            .queue_begin_debug_utils_label_ext(queue, label);
+        (self.fp.queue_begin_debug_utils_label_ext)(queue, label);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueEndDebugUtilsLabelEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueEndDebugUtilsLabelEXT.html>
+    #[inline]
     pub unsafe fn queue_end_debug_utils_label(&self, queue: vk::Queue) {
-        self.debug_utils_fn.queue_end_debug_utils_label_ext(queue);
+        (self.fp.queue_end_debug_utils_label_ext)(queue);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueInsertDebugUtilsLabelEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueInsertDebugUtilsLabelEXT.html>
+    #[inline]
     pub unsafe fn queue_insert_debug_utils_label(
         &self,
         queue: vk::Queue,
         label: &vk::DebugUtilsLabelEXT,
     ) {
-        self.debug_utils_fn
-            .queue_insert_debug_utils_label_ext(queue, label);
+        (self.fp.queue_insert_debug_utils_label_ext)(queue, label);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDebugUtilsMessengerEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDebugUtilsMessengerEXT.html>
+    #[inline]
     pub unsafe fn create_debug_utils_messenger(
         &self,
         create_info: &vk::DebugUtilsMessengerCreateInfoEXT,
         allocator: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DebugUtilsMessengerEXT> {
         let mut messenger = mem::zeroed();
-        self.debug_utils_fn
-            .create_debug_utils_messenger_ext(
-                self.handle,
-                create_info,
-                allocator.as_raw_ptr(),
-                &mut messenger,
-            )
-            .result_with_success(messenger)
+        (self.fp.create_debug_utils_messenger_ext)(
+            self.handle,
+            create_info,
+            allocator.as_raw_ptr(),
+            &mut messenger,
+        )
+        .result_with_success(messenger)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDebugUtilsMessengerEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDebugUtilsMessengerEXT.html>
+    #[inline]
     pub unsafe fn destroy_debug_utils_messenger(
         &self,
         messenger: vk::DebugUtilsMessengerEXT,
         allocator: Option<&vk::AllocationCallbacks>,
     ) {
-        self.debug_utils_fn.destroy_debug_utils_messenger_ext(
-            self.handle,
-            messenger,
-            allocator.as_raw_ptr(),
-        );
+        (self.fp.destroy_debug_utils_messenger_ext)(self.handle, messenger, allocator.as_raw_ptr());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSubmitDebugUtilsMessageEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSubmitDebugUtilsMessageEXT.html>
+    #[inline]
     pub unsafe fn submit_debug_utils_message(
         &self,
-        instance: vk::Instance,
         message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
         message_types: vk::DebugUtilsMessageTypeFlagsEXT,
         callback_data: &vk::DebugUtilsMessengerCallbackDataEXT,
     ) {
-        self.debug_utils_fn.submit_debug_utils_message_ext(
-            instance,
+        (self.fp.submit_debug_utils_message_ext)(
+            self.handle,
             message_severity,
             message_types,
             callback_data,
         );
     }
 
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtDebugUtilsFn::name()
+    }
+
+    #[inline]
     pub fn fp(&self) -> &vk::ExtDebugUtilsFn {
-        &self.debug_utils_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/ext/descriptor_buffer.rs b/src/extensions/ext/descriptor_buffer.rs
new file mode 100644
index 0000000..4503f5b
--- /dev/null
+++ b/src/extensions/ext/descriptor_buffer.rs
@@ -0,0 +1,211 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_descriptor_buffer.html>
+#[derive(Clone)]
+pub struct DescriptorBuffer {
+    handle: vk::Device,
+    fp: vk::ExtDescriptorBufferFn,
+}
+
+impl DescriptorBuffer {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::ExtDescriptorBufferFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDescriptorSetLayoutSizeEXT.html>
+    #[inline]
+    pub unsafe fn get_descriptor_set_layout_size(
+        &self,
+        layout: vk::DescriptorSetLayout,
+    ) -> vk::DeviceSize {
+        let mut count = 0;
+        (self.fp.get_descriptor_set_layout_size_ext)(self.handle, layout, &mut count);
+        count
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html>
+    #[inline]
+    pub unsafe fn get_descriptor_set_layout_binding_offset(
+        &self,
+        layout: vk::DescriptorSetLayout,
+        binding: u32,
+    ) -> vk::DeviceSize {
+        let mut offset = 0;
+        (self.fp.get_descriptor_set_layout_binding_offset_ext)(
+            self.handle,
+            layout,
+            binding,
+            &mut offset,
+        );
+        offset
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDescriptorEXT.html>
+    #[inline]
+    pub unsafe fn get_descriptor(
+        &self,
+        descriptor_info: &vk::DescriptorGetInfoEXT,
+        descriptor: &mut [u8],
+    ) {
+        (self.fp.get_descriptor_ext)(
+            self.handle,
+            descriptor_info,
+            descriptor.len(),
+            descriptor.as_mut_ptr().cast(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindDescriptorBuffersEXT.html>
+    #[inline]
+    pub unsafe fn cmd_bind_descriptor_buffers(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        binding_info: &[vk::DescriptorBufferBindingInfoEXT],
+    ) {
+        (self.fp.cmd_bind_descriptor_buffers_ext)(
+            command_buffer,
+            binding_info.len() as u32,
+            binding_info.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_descriptor_buffer_offsets(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        pipeline_bind_point: vk::PipelineBindPoint,
+        layout: vk::PipelineLayout,
+        first_set: u32,
+        buffer_indices: &[u32],
+        offsets: &[vk::DeviceSize],
+    ) {
+        assert_eq!(buffer_indices.len(), offsets.len());
+        (self.fp.cmd_set_descriptor_buffer_offsets_ext)(
+            command_buffer,
+            pipeline_bind_point,
+            layout,
+            first_set,
+            buffer_indices.len() as u32,
+            buffer_indices.as_ptr(),
+            offsets.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html>
+    #[inline]
+    pub unsafe fn cmd_bind_descriptor_buffer_embedded_samplers(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        pipeline_bind_point: vk::PipelineBindPoint,
+        layout: vk::PipelineLayout,
+        set: u32,
+    ) {
+        (self.fp.cmd_bind_descriptor_buffer_embedded_samplers_ext)(
+            command_buffer,
+            pipeline_bind_point,
+            layout,
+            set,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html>
+    #[inline]
+    pub unsafe fn get_buffer_opaque_capture_descriptor_data(
+        &self,
+        info: &vk::BufferCaptureDescriptorDataInfoEXT,
+        data: &mut [u8],
+    ) -> VkResult<()> {
+        (self.fp.get_buffer_opaque_capture_descriptor_data_ext)(
+            self.handle,
+            info,
+            data.as_mut_ptr().cast(),
+        )
+        .result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html>
+    #[inline]
+    pub unsafe fn get_image_opaque_capture_descriptor_data(
+        &self,
+        info: &vk::ImageCaptureDescriptorDataInfoEXT,
+        data: &mut [u8],
+    ) -> VkResult<()> {
+        (self.fp.get_image_opaque_capture_descriptor_data_ext)(
+            self.handle,
+            info,
+            data.as_mut_ptr().cast(),
+        )
+        .result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html>
+    #[inline]
+    pub unsafe fn get_image_view_opaque_capture_descriptor_data(
+        &self,
+        info: &vk::ImageViewCaptureDescriptorDataInfoEXT,
+        data: &mut [u8],
+    ) -> VkResult<()> {
+        (self.fp.get_image_view_opaque_capture_descriptor_data_ext)(
+            self.handle,
+            info,
+            data.as_mut_ptr().cast(),
+        )
+        .result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html>
+    #[inline]
+    pub unsafe fn get_sampler_opaque_capture_descriptor_data(
+        &self,
+        info: &vk::SamplerCaptureDescriptorDataInfoEXT,
+        data: &mut [u8],
+    ) -> VkResult<()> {
+        (self.fp.get_sampler_opaque_capture_descriptor_data_ext)(
+            self.handle,
+            info,
+            data.as_mut_ptr().cast(),
+        )
+        .result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html>
+    #[inline]
+    pub unsafe fn get_acceleration_structure_opaque_capture_descriptor_data(
+        &self,
+        info: &vk::AccelerationStructureCaptureDescriptorDataInfoEXT,
+        data: &mut [u8],
+    ) -> VkResult<()> {
+        (self
+            .fp
+            .get_acceleration_structure_opaque_capture_descriptor_data_ext)(
+            self.handle,
+            info,
+            data.as_mut_ptr().cast(),
+        )
+        .result()
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtDescriptorBufferFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtDescriptorBufferFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/ext/extended_dynamic_state.rs b/src/extensions/ext/extended_dynamic_state.rs
index acd5408..2e6b3ee 100644
--- a/src/extensions/ext/extended_dynamic_state.rs
+++ b/src/extensions/ext/extended_dynamic_state.rs
@@ -6,84 +6,77 @@ use std::ptr;
 
 #[derive(Clone)]
 pub struct ExtendedDynamicState {
-    handle: vk::Instance,
-    extended_dynamic_state_fn: vk::ExtExtendedDynamicStateFn,
+    fp: vk::ExtExtendedDynamicStateFn,
 }
 
 impl ExtendedDynamicState {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let extended_dynamic_state_fn = vk::ExtExtendedDynamicStateFn::load(|name| unsafe {
+        let fp = vk::ExtExtendedDynamicStateFn::load(|name| unsafe {
             mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            extended_dynamic_state_fn,
-        }
+        Self { fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::ExtExtendedDynamicStateFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetCullModeEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCullModeEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_cull_mode(
         &self,
         command_buffer: vk::CommandBuffer,
         cull_mode: vk::CullModeFlags,
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_cull_mode_ext(command_buffer, cull_mode)
+        (self.fp.cmd_set_cull_mode_ext)(command_buffer, cull_mode)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetFrontFaceEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetFrontFaceEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_front_face(
         &self,
         command_buffer: vk::CommandBuffer,
         front_face: vk::FrontFace,
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_front_face_ext(command_buffer, front_face)
+        (self.fp.cmd_set_front_face_ext)(command_buffer, front_face)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetPrimitiveTopologyEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveTopologyEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_primitive_topology(
         &self,
         command_buffer: vk::CommandBuffer,
         primitive_topology: vk::PrimitiveTopology,
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_primitive_topology_ext(command_buffer, primitive_topology)
+        (self.fp.cmd_set_primitive_topology_ext)(command_buffer, primitive_topology)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetViewportWithCountEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportWithCountEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_viewport_with_count(
         &self,
         command_buffer: vk::CommandBuffer,
         viewports: &[vk::Viewport],
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_viewport_with_count_ext(
-                command_buffer,
-                viewports.len() as u32,
-                viewports.as_ptr(),
-            )
+        (self.fp.cmd_set_viewport_with_count_ext)(
+            command_buffer,
+            viewports.len() as u32,
+            viewports.as_ptr(),
+        )
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetScissorWithCountEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetScissorWithCountEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_scissor_with_count(
         &self,
         command_buffer: vk::CommandBuffer,
         scissors: &[vk::Rect2D],
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_scissor_with_count_ext(
-                command_buffer,
-                scissors.len() as u32,
-                scissors.as_ptr(),
-            )
+        (self.fp.cmd_set_scissor_with_count_ext)(
+            command_buffer,
+            scissors.len() as u32,
+            scissors.as_ptr(),
+        )
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindVertexBuffers2EXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindVertexBuffers2EXT.html>
+    #[inline]
     pub unsafe fn cmd_bind_vertex_buffers2(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -106,7 +99,7 @@ impl ExtendedDynamicState {
         } else {
             ptr::null()
         };
-        self.extended_dynamic_state_fn.cmd_bind_vertex_buffers2_ext(
+        (self.fp.cmd_bind_vertex_buffers2_ext)(
             command_buffer,
             first_binding,
             buffers.len() as u32,
@@ -117,57 +110,61 @@ impl ExtendedDynamicState {
         )
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthTestEnableEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthTestEnableEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_depth_test_enable(
         &self,
         command_buffer: vk::CommandBuffer,
         depth_test_enable: bool,
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_depth_test_enable_ext(command_buffer, depth_test_enable.into())
+        (self.fp.cmd_set_depth_test_enable_ext)(command_buffer, depth_test_enable.into())
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthWriteEnableEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthWriteEnableEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_depth_write_enable(
         &self,
         command_buffer: vk::CommandBuffer,
         depth_write_enable: bool,
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_depth_write_enable_ext(command_buffer, depth_write_enable.into())
+        (self.fp.cmd_set_depth_write_enable_ext)(command_buffer, depth_write_enable.into())
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthCompareOpEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthCompareOpEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_depth_compare_op(
         &self,
         command_buffer: vk::CommandBuffer,
         depth_compare_op: vk::CompareOp,
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_depth_compare_op_ext(command_buffer, depth_compare_op)
+        (self.fp.cmd_set_depth_compare_op_ext)(command_buffer, depth_compare_op)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBoundsTestEnableEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBoundsTestEnableEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_depth_bounds_test_enable(
         &self,
         command_buffer: vk::CommandBuffer,
         depth_bounds_test_enable: bool,
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_depth_bounds_test_enable_ext(command_buffer, depth_bounds_test_enable.into())
+        (self.fp.cmd_set_depth_bounds_test_enable_ext)(
+            command_buffer,
+            depth_bounds_test_enable.into(),
+        )
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilTestEnableEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilTestEnableEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_stencil_test_enable(
         &self,
         command_buffer: vk::CommandBuffer,
         stencil_test_enable: bool,
     ) {
-        self.extended_dynamic_state_fn
-            .cmd_set_stencil_test_enable_ext(command_buffer, stencil_test_enable.into())
+        (self.fp.cmd_set_stencil_test_enable_ext)(command_buffer, stencil_test_enable.into())
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilOpEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilOpEXT.html>
+    #[inline]
     pub unsafe fn cmd_set_stencil_op(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -177,7 +174,7 @@ impl ExtendedDynamicState {
         depth_fail_op: vk::StencilOp,
         compare_op: vk::CompareOp,
     ) {
-        self.extended_dynamic_state_fn.cmd_set_stencil_op_ext(
+        (self.fp.cmd_set_stencil_op_ext)(
             command_buffer,
             face_mask,
             fail_op,
@@ -187,11 +184,13 @@ impl ExtendedDynamicState {
         )
     }
 
-    pub fn fp(&self) -> &vk::ExtExtendedDynamicStateFn {
-        &self.extended_dynamic_state_fn
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtExtendedDynamicStateFn::name()
     }
 
-    pub fn instance(&self) -> vk::Instance {
-        self.handle
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtExtendedDynamicStateFn {
+        &self.fp
     }
 }
diff --git a/src/extensions/ext/extended_dynamic_state2.rs b/src/extensions/ext/extended_dynamic_state2.rs
new file mode 100644
index 0000000..b515385
--- /dev/null
+++ b/src/extensions/ext/extended_dynamic_state2.rs
@@ -0,0 +1,85 @@
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_extended_dynamic_state2.html>
+#[derive(Clone)]
+pub struct ExtendedDynamicState2 {
+    fp: vk::ExtExtendedDynamicState2Fn,
+}
+
+impl ExtendedDynamicState2 {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let fp = vk::ExtExtendedDynamicState2Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPatchControlPointsEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_patch_control_points(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        patch_control_points: u32,
+    ) {
+        (self.fp.cmd_set_patch_control_points_ext)(command_buffer, patch_control_points)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizerDiscardEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_rasterizer_discard_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        rasterizer_discard_enable: bool,
+    ) {
+        (self.fp.cmd_set_rasterizer_discard_enable_ext)(
+            command_buffer,
+            rasterizer_discard_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBiasEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_bias_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_bias_enable: bool,
+    ) {
+        (self.fp.cmd_set_depth_bias_enable_ext)(command_buffer, depth_bias_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLogicOpEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_logic_op(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        logic_op: vk::LogicOp,
+    ) {
+        (self.fp.cmd_set_logic_op_ext)(command_buffer, logic_op)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveRestartEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_primitive_restart_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        primitive_restart_enable: bool,
+    ) {
+        (self.fp.cmd_set_primitive_restart_enable_ext)(
+            command_buffer,
+            primitive_restart_enable.into(),
+        )
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtExtendedDynamicState2Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtExtendedDynamicState2Fn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/ext/extended_dynamic_state3.rs b/src/extensions/ext/extended_dynamic_state3.rs
new file mode 100644
index 0000000..bb68f75
--- /dev/null
+++ b/src/extensions/ext/extended_dynamic_state3.rs
@@ -0,0 +1,409 @@
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_extended_dynamic_state3.html>
+#[derive(Clone)]
+pub struct ExtendedDynamicState3 {
+    fp: vk::ExtExtendedDynamicState3Fn,
+}
+
+impl ExtendedDynamicState3 {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let fp = vk::ExtExtendedDynamicState3Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetTessellationDomainOriginEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_tessellation_domain_origin(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        domain_origin: vk::TessellationDomainOrigin,
+    ) {
+        (self.fp.cmd_set_tessellation_domain_origin_ext)(command_buffer, domain_origin)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClampEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_clamp_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_clamp_enable: bool,
+    ) {
+        (self.fp.cmd_set_depth_clamp_enable_ext)(command_buffer, depth_clamp_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPolygonModeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_polygon_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        polygon_mode: vk::PolygonMode,
+    ) {
+        (self.fp.cmd_set_polygon_mode_ext)(command_buffer, polygon_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizationSamplesEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_rasterization_samples(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        rasterization_samples: vk::SampleCountFlags,
+    ) {
+        (self.fp.cmd_set_rasterization_samples_ext)(command_buffer, rasterization_samples)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleMaskEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_sample_mask(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        samples: vk::SampleCountFlags,
+        sample_mask: &[vk::SampleMask],
+    ) {
+        assert!(
+            samples.as_raw().is_power_of_two(),
+            "Only one SampleCount bit must be set"
+        );
+        assert_eq!(samples.as_raw() as usize / 32, sample_mask.len());
+        (self.fp.cmd_set_sample_mask_ext)(command_buffer, samples, sample_mask.as_ptr())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetAlphaToCoverageEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_alpha_to_coverage_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        alpha_to_coverage_enable: bool,
+    ) {
+        (self.fp.cmd_set_alpha_to_coverage_enable_ext)(
+            command_buffer,
+            alpha_to_coverage_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetAlphaToOneEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_alpha_to_one_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        alpha_to_one_enable: bool,
+    ) {
+        (self.fp.cmd_set_alpha_to_one_enable_ext)(command_buffer, alpha_to_one_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLogicOpEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_logic_op_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        logic_op_enable: bool,
+    ) {
+        (self.fp.cmd_set_logic_op_enable_ext)(command_buffer, logic_op_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_color_blend_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        color_blend_enables: &[vk::Bool32],
+    ) {
+        (self.fp.cmd_set_color_blend_enable_ext)(
+            command_buffer,
+            first_attachment,
+            color_blend_enables.len() as u32,
+            color_blend_enables.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendEquationEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_color_blend_equation(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        color_blend_equations: &[vk::ColorBlendEquationEXT],
+    ) {
+        (self.fp.cmd_set_color_blend_equation_ext)(
+            command_buffer,
+            first_attachment,
+            color_blend_equations.len() as u32,
+            color_blend_equations.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorWriteMaskEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_color_write_mask(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        color_write_masks: &[vk::ColorComponentFlags],
+    ) {
+        (self.fp.cmd_set_color_write_mask_ext)(
+            command_buffer,
+            first_attachment,
+            color_write_masks.len() as u32,
+            color_write_masks.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizationStreamEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_rasterization_stream(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        rasterization_stream: u32,
+    ) {
+        (self.fp.cmd_set_rasterization_stream_ext)(command_buffer, rasterization_stream)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetConservativeRasterizationModeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_conservative_rasterization_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        conservative_rasterization_mode: vk::ConservativeRasterizationModeEXT,
+    ) {
+        (self.fp.cmd_set_conservative_rasterization_mode_ext)(
+            command_buffer,
+            conservative_rasterization_mode,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_extra_primitive_overestimation_size(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        extra_primitive_overestimation_size: f32,
+    ) {
+        (self.fp.cmd_set_extra_primitive_overestimation_size_ext)(
+            command_buffer,
+            extra_primitive_overestimation_size,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClipEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_clip_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_clip_enable: bool,
+    ) {
+        (self.fp.cmd_set_depth_clip_enable_ext)(command_buffer, depth_clip_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleLocationsEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_sample_locations_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        sample_locations_enable: bool,
+    ) {
+        (self.fp.cmd_set_sample_locations_enable_ext)(
+            command_buffer,
+            sample_locations_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendAdvancedEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_color_blend_advanced(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        color_blend_advanced: &[vk::ColorBlendAdvancedEXT],
+    ) {
+        (self.fp.cmd_set_color_blend_advanced_ext)(
+            command_buffer,
+            first_attachment,
+            color_blend_advanced.len() as u32,
+            color_blend_advanced.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetProvokingVertexModeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_provoking_vertex_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        provoking_vertex_mode: vk::ProvokingVertexModeEXT,
+    ) {
+        (self.fp.cmd_set_provoking_vertex_mode_ext)(command_buffer, provoking_vertex_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineRasterizationModeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_line_rasterization_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        line_rasterization_mode: vk::LineRasterizationModeEXT,
+    ) {
+        (self.fp.cmd_set_line_rasterization_mode_ext)(command_buffer, line_rasterization_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineStippleEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_line_stipple_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        stippled_line_enable: bool,
+    ) {
+        (self.fp.cmd_set_line_stipple_enable_ext)(command_buffer, stippled_line_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_clip_negative_one_to_one(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        negative_one_to_one: bool,
+    ) {
+        (self.fp.cmd_set_depth_clip_negative_one_to_one_ext)(
+            command_buffer,
+            negative_one_to_one.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportWScalingEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_viewport_w_scaling_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        viewport_w_scaling_enable: bool,
+    ) {
+        (self.fp.cmd_set_viewport_w_scaling_enable_nv)(
+            command_buffer,
+            viewport_w_scaling_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportSwizzleNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_viewport_swizzle_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        viewport_swizzles: &[vk::ViewportSwizzleNV],
+    ) {
+        (self.fp.cmd_set_viewport_swizzle_nv)(
+            command_buffer,
+            first_attachment,
+            viewport_swizzles.len() as u32,
+            viewport_swizzles.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageToColorEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_to_color_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_to_color_enable: bool,
+    ) {
+        (self.fp.cmd_set_coverage_to_color_enable_nv)(
+            command_buffer,
+            coverage_to_color_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageToColorLocationNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_to_color_location_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_to_color_location: u32,
+    ) {
+        (self.fp.cmd_set_coverage_to_color_location_nv)(command_buffer, coverage_to_color_location)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationModeNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_modulation_mode_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_modulation_mode: vk::CoverageModulationModeNV,
+    ) {
+        (self.fp.cmd_set_coverage_modulation_mode_nv)(command_buffer, coverage_modulation_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationTableEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_modulation_table_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_modulation_table_enable: bool,
+    ) {
+        (self.fp.cmd_set_coverage_modulation_table_enable_nv)(
+            command_buffer,
+            coverage_modulation_table_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationTableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_modulation_table_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_modulation_table: &[f32],
+    ) {
+        (self.fp.cmd_set_coverage_modulation_table_nv)(
+            command_buffer,
+            coverage_modulation_table.len() as u32,
+            coverage_modulation_table.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetShadingRateImageEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_shading_rate_image_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        shading_rate_image_enable: bool,
+    ) {
+        (self.fp.cmd_set_shading_rate_image_enable_nv)(
+            command_buffer,
+            shading_rate_image_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_representative_fragment_test_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        representative_fragment_test_enable: bool,
+    ) {
+        (self.fp.cmd_set_representative_fragment_test_enable_nv)(
+            command_buffer,
+            representative_fragment_test_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageReductionModeNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_reduction_mode_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_reduction_mode: vk::CoverageReductionModeNV,
+    ) {
+        (self.fp.cmd_set_coverage_reduction_mode_nv)(command_buffer, coverage_reduction_mode)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtExtendedDynamicState3Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtExtendedDynamicState3Fn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/ext/full_screen_exclusive.rs b/src/extensions/ext/full_screen_exclusive.rs
index 59d546d..c511869 100644
--- a/src/extensions/ext/full_screen_exclusive.rs
+++ b/src/extensions/ext/full_screen_exclusive.rs
@@ -1,86 +1,110 @@
 use crate::prelude::*;
 use crate::vk;
-use crate::{Device, Instance};
+use crate::{Device, Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_full_screen_exclusive.html>
 #[derive(Clone)]
 pub struct FullScreenExclusive {
     handle: vk::Device,
-    full_screen_exclusive_fn: vk::ExtFullScreenExclusiveFn,
+    fp: vk::ExtFullScreenExclusiveFn,
 }
 
 impl FullScreenExclusive {
+    /// # Warning
+    /// [`Instance`] functions cannot be loaded from a [`Device`] and will always panic when called:
+    /// - [`Self::get_physical_device_surface_present_modes2()`]
+    ///
+    /// Load this struct using an [`Instance`] instead via [`Self::new_from_instance()`] if the
+    /// above [`Instance`] function is called. This will be solved in the next breaking `ash`
+    /// release: <https://github.com/ash-rs/ash/issues/727>.
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let full_screen_exclusive_fn = vk::ExtFullScreenExclusiveFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::ExtFullScreenExclusiveFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            full_screen_exclusive_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::ExtFullScreenExclusiveFn::name()
+    /// Loads all functions on the [`Instance`] instead of [`Device`]. This incurs an extra
+    /// dispatch table for [`Device`] functions but also allows the [`Instance`] function to be
+    /// loaded instead of always panicking. See also [`Self::new()`] for more details.
+    ///
+    /// It is okay to pass [`vk::Device::null()`] when this struct is only used to call the
+    /// [`Instance`] function.
+    pub fn new_from_instance(entry: &Entry, instance: &Instance, device: vk::Device) -> Self {
+        let fp = vk::ExtFullScreenExclusiveFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { handle: device, fp }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireFullScreenExclusiveModeEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireFullScreenExclusiveModeEXT.html>
+    #[inline]
     pub unsafe fn acquire_full_screen_exclusive_mode(
         &self,
         swapchain: vk::SwapchainKHR,
     ) -> VkResult<()> {
-        self.full_screen_exclusive_fn
-            .acquire_full_screen_exclusive_mode_ext(self.handle, swapchain)
-            .result()
+        (self.fp.acquire_full_screen_exclusive_mode_ext)(self.handle, swapchain).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html>
+    ///
+    /// # Warning
+    ///
+    /// Function will always panic unless this struct is loaded via [`Self::new_from_instance()`].
+    #[inline]
     pub unsafe fn get_physical_device_surface_present_modes2(
         &self,
         physical_device: vk::PhysicalDevice,
         surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR,
     ) -> VkResult<Vec<vk::PresentModeKHR>> {
         read_into_uninitialized_vector(|count, data| {
-            self.full_screen_exclusive_fn
-                .get_physical_device_surface_present_modes2_ext(
-                    physical_device,
-                    surface_info,
-                    count,
-                    data,
-                )
+            (self.fp.get_physical_device_surface_present_modes2_ext)(
+                physical_device,
+                surface_info,
+                count,
+                data,
+            )
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkReleaseFullScreenExclusiveModeEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkReleaseFullScreenExclusiveModeEXT.html>
+    #[inline]
     pub unsafe fn release_full_screen_exclusive_mode(
         &self,
         swapchain: vk::SwapchainKHR,
     ) -> VkResult<()> {
-        self.full_screen_exclusive_fn
-            .release_full_screen_exclusive_mode_ext(self.handle, swapchain)
-            .result()
+        (self.fp.release_full_screen_exclusive_mode_ext)(self.handle, swapchain).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html>
+    #[inline]
     pub unsafe fn get_device_group_surface_present_modes2(
         &self,
         surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR,
     ) -> VkResult<vk::DeviceGroupPresentModeFlagsKHR> {
         let mut present_modes = mem::zeroed();
-        self.full_screen_exclusive_fn
-            .get_device_group_surface_present_modes2_ext(
-                self.handle,
-                surface_info,
-                &mut present_modes,
-            )
-            .result_with_success(present_modes)
+        (self.fp.get_device_group_surface_present_modes2_ext)(
+            self.handle,
+            surface_info,
+            &mut present_modes,
+        )
+        .result_with_success(present_modes)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtFullScreenExclusiveFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::ExtFullScreenExclusiveFn {
-        &self.full_screen_exclusive_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/ext/headless_surface.rs b/src/extensions/ext/headless_surface.rs
new file mode 100644
index 0000000..fe04236
--- /dev/null
+++ b/src/extensions/ext/headless_surface.rs
@@ -0,0 +1,55 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::RawPtr;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_headless_surface.html>
+#[derive(Clone)]
+pub struct HeadlessSurface {
+    handle: vk::Instance,
+    fp: vk::ExtHeadlessSurfaceFn,
+}
+
+impl HeadlessSurface {
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::ExtHeadlessSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateHeadlessSurfaceEXT.html>
+    #[inline]
+    pub unsafe fn create_headless_surface(
+        &self,
+        create_info: &vk::HeadlessSurfaceCreateInfoEXT,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SurfaceKHR> {
+        let mut surface = mem::zeroed();
+        (self.fp.create_headless_surface_ext)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtHeadlessSurfaceFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtHeadlessSurfaceFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn instance(&self) -> vk::Instance {
+        self.handle
+    }
+}
diff --git a/src/extensions/ext/image_compression_control.rs b/src/extensions/ext/image_compression_control.rs
new file mode 100644
index 0000000..a326116
--- /dev/null
+++ b/src/extensions/ext/image_compression_control.rs
@@ -0,0 +1,47 @@
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_image_compression_control.html>
+#[derive(Clone)]
+pub struct ImageCompressionControl {
+    handle: vk::Device,
+    fp: vk::ExtImageCompressionControlFn,
+}
+
+impl ImageCompressionControl {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::ExtImageCompressionControlFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageSubresourceLayout2EXT.html>
+    #[inline]
+    pub unsafe fn get_image_subresource_layout2(
+        &self,
+        image: vk::Image,
+        subresource: &vk::ImageSubresource2EXT,
+        layout: &mut vk::SubresourceLayout2EXT,
+    ) {
+        (self.fp.get_image_subresource_layout2_ext)(self.handle, image, subresource, layout)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtImageCompressionControlFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtImageCompressionControlFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/ext/image_drm_format_modifier.rs b/src/extensions/ext/image_drm_format_modifier.rs
new file mode 100644
index 0000000..ccdce2e
--- /dev/null
+++ b/src/extensions/ext/image_drm_format_modifier.rs
@@ -0,0 +1,48 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_image_drm_format_modifier.html>
+#[derive(Clone)]
+pub struct ImageDrmFormatModifier {
+    handle: vk::Device,
+    fp: vk::ExtImageDrmFormatModifierFn,
+}
+
+impl ImageDrmFormatModifier {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::ExtImageDrmFormatModifierFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html>
+    #[inline]
+    pub unsafe fn get_image_drm_format_modifier_properties(
+        &self,
+        image: vk::Image,
+        properties: &mut vk::ImageDrmFormatModifierPropertiesEXT,
+    ) -> VkResult<()> {
+        (self.fp.get_image_drm_format_modifier_properties_ext)(self.handle, image, properties)
+            .result()
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtImageDrmFormatModifierFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtImageDrmFormatModifierFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/ext/mesh_shader.rs b/src/extensions/ext/mesh_shader.rs
new file mode 100644
index 0000000..7d58f0c
--- /dev/null
+++ b/src/extensions/ext/mesh_shader.rs
@@ -0,0 +1,94 @@
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_mesh_shader.html>
+#[derive(Clone)]
+pub struct MeshShader {
+    fp: vk::ExtMeshShaderFn,
+}
+
+impl MeshShader {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let fp = vk::ExtMeshShaderFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksEXT.html>
+    #[inline]
+    pub unsafe fn cmd_draw_mesh_tasks(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        group_count_x: u32,
+        group_count_y: u32,
+        group_count_z: u32,
+    ) {
+        (self.fp.cmd_draw_mesh_tasks_ext)(
+            command_buffer,
+            group_count_x,
+            group_count_y,
+            group_count_z,
+        );
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectEXT.html>
+    ///
+    /// `buffer` contains `draw_count` [`vk::DrawMeshTasksIndirectCommandEXT`] structures starting at `offset` in bytes, holding the draw parameters.
+    #[inline]
+    pub unsafe fn cmd_draw_mesh_tasks_indirect(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        buffer: vk::Buffer,
+        offset: vk::DeviceSize,
+        draw_count: u32,
+        stride: u32,
+    ) {
+        (self.fp.cmd_draw_mesh_tasks_indirect_ext)(
+            command_buffer,
+            buffer,
+            offset,
+            draw_count,
+            stride,
+        );
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html>
+    ///
+    /// `buffer` contains a maximum of `max_draw_count` [`vk::DrawMeshTasksIndirectCommandEXT`] structures starting at `offset` in bytes, holding the draw parameters.
+    /// `count_buffer` is the buffer containing the draw count, starting at `count_buffer_offset` in bytes.
+    /// The actual number of executed draw calls is the minimum of the count specified in `count_buffer` and `max_draw_count`.
+    #[inline]
+    pub unsafe fn cmd_draw_mesh_tasks_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,
+    ) {
+        (self.fp.cmd_draw_mesh_tasks_indirect_count_ext)(
+            command_buffer,
+            buffer,
+            offset,
+            count_buffer,
+            count_buffer_offset,
+            max_draw_count,
+            stride,
+        );
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtMeshShaderFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtMeshShaderFn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/ext/metal_surface.rs b/src/extensions/ext/metal_surface.rs
index c76d436..9627d2f 100644
--- a/src/extensions/ext/metal_surface.rs
+++ b/src/extensions/ext/metal_surface.rs
@@ -1,52 +1,53 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct MetalSurface {
     handle: vk::Instance,
-    metal_surface_fn: vk::ExtMetalSurfaceFn,
+    fp: vk::ExtMetalSurfaceFn,
 }
 
 impl MetalSurface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::ExtMetalSurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::ExtMetalSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            metal_surface_fn: surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::ExtMetalSurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateMetalSurfaceEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateMetalSurfaceEXT.html>
+    #[inline]
     pub unsafe fn create_metal_surface(
         &self,
         create_info: &vk::MetalSurfaceCreateInfoEXT,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        self.metal_surface_fn
-            .create_metal_surface_ext(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut surface,
-            )
-            .result_with_success(surface)
+        (self.fp.create_metal_surface_ext)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtMetalSurfaceFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::ExtMetalSurfaceFn {
-        &self.metal_surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/ext/mod.rs b/src/extensions/ext/mod.rs
index e25806e..8d4c5a2 100644
--- a/src/extensions/ext/mod.rs
+++ b/src/extensions/ext/mod.rs
@@ -1,23 +1,49 @@
+pub use self::acquire_drm_display::AcquireDrmDisplay;
 pub use self::buffer_device_address::BufferDeviceAddress;
+pub use self::calibrated_timestamps::CalibratedTimestamps;
 #[allow(deprecated)]
 pub use self::debug_marker::DebugMarker;
 #[allow(deprecated)]
 pub use self::debug_report::DebugReport;
 pub use self::debug_utils::DebugUtils;
+pub use self::descriptor_buffer::DescriptorBuffer;
 pub use self::extended_dynamic_state::ExtendedDynamicState;
+pub use self::extended_dynamic_state2::ExtendedDynamicState2;
+pub use self::extended_dynamic_state3::ExtendedDynamicState3;
 pub use self::full_screen_exclusive::FullScreenExclusive;
+pub use self::headless_surface::HeadlessSurface;
+pub use self::image_compression_control::ImageCompressionControl;
+pub use self::image_drm_format_modifier::ImageDrmFormatModifier;
+pub use self::mesh_shader::MeshShader;
 pub use self::metal_surface::MetalSurface;
 pub use self::physical_device_drm::PhysicalDeviceDrm;
+pub use self::pipeline_properties::PipelineProperties;
+pub use self::private_data::PrivateData;
+pub use self::sample_locations::SampleLocations;
+pub use self::shader_object::ShaderObject;
 pub use self::tooling_info::ToolingInfo;
 
+mod acquire_drm_display;
 mod buffer_device_address;
+mod calibrated_timestamps;
 #[deprecated(note = "Please use the [DebugUtils](struct.DebugUtils.html) extension instead.")]
 mod debug_marker;
 #[deprecated(note = "Please use the [DebugUtils](struct.DebugUtils.html) extension instead.")]
 mod debug_report;
 mod debug_utils;
+mod descriptor_buffer;
 mod extended_dynamic_state;
+mod extended_dynamic_state2;
+mod extended_dynamic_state3;
 mod full_screen_exclusive;
+mod headless_surface;
+mod image_compression_control;
+mod image_drm_format_modifier;
+mod mesh_shader;
 mod metal_surface;
 mod physical_device_drm;
+mod pipeline_properties;
+mod private_data;
+mod sample_locations;
+mod shader_object;
 mod tooling_info;
diff --git a/src/extensions/ext/physical_device_drm.rs b/src/extensions/ext/physical_device_drm.rs
index 56ca314..29b6cd7 100644
--- a/src/extensions/ext/physical_device_drm.rs
+++ b/src/extensions/ext/physical_device_drm.rs
@@ -6,6 +6,7 @@ use std::ffi::CStr;
 pub struct PhysicalDeviceDrm;
 
 impl PhysicalDeviceDrm {
+    #[inline]
     pub unsafe fn get_properties(
         instance: &Instance,
         pdevice: vk::PhysicalDevice,
@@ -18,7 +19,8 @@ impl PhysicalDeviceDrm {
         props_drm
     }
 
-    pub fn name() -> &'static CStr {
+    #[inline]
+    pub const fn name() -> &'static CStr {
         vk::ExtPhysicalDeviceDrmFn::name()
     }
 }
diff --git a/src/extensions/ext/pipeline_properties.rs b/src/extensions/ext/pipeline_properties.rs
new file mode 100644
index 0000000..09b6b19
--- /dev/null
+++ b/src/extensions/ext/pipeline_properties.rs
@@ -0,0 +1,52 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_pipeline_properties.html>
+#[derive(Clone)]
+pub struct PipelineProperties {
+    handle: vk::Device,
+    fp: vk::ExtPipelinePropertiesFn,
+}
+
+impl PipelineProperties {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::ExtPipelinePropertiesFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPipelinePropertiesEXT.html>
+    #[inline]
+    pub unsafe fn get_pipeline_properties(
+        &self,
+        pipeline_info: &vk::PipelineInfoEXT,
+        pipeline_properties: &mut impl vk::GetPipelinePropertiesEXTParamPipelineProperties,
+    ) -> VkResult<()> {
+        (self.fp.get_pipeline_properties_ext)(
+            self.handle,
+            pipeline_info,
+            <*mut _>::cast(pipeline_properties),
+        )
+        .result()
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtPipelinePropertiesFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtPipelinePropertiesFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/ext/private_data.rs b/src/extensions/ext/private_data.rs
new file mode 100644
index 0000000..c6cc6ae
--- /dev/null
+++ b/src/extensions/ext/private_data.rs
@@ -0,0 +1,105 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::RawPtr;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_private_data.html>
+#[derive(Clone)]
+pub struct PrivateData {
+    handle: vk::Device,
+    fp: vk::ExtPrivateDataFn,
+}
+
+impl PrivateData {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::ExtPrivateDataFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreatePrivateDataSlotEXT.html>
+    #[inline]
+    pub unsafe fn create_private_data_slot(
+        &self,
+        create_info: &vk::PrivateDataSlotCreateInfoEXT,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::PrivateDataSlotEXT> {
+        let mut private_data_slot = mem::zeroed();
+        (self.fp.create_private_data_slot_ext)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut private_data_slot,
+        )
+        .result_with_success(private_data_slot)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyPrivateDataSlotEXT.html>
+    #[inline]
+    pub unsafe fn destroy_private_data_slot(
+        &self,
+        private_data_slot: vk::PrivateDataSlotEXT,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) {
+        (self.fp.destroy_private_data_slot_ext)(
+            self.handle,
+            private_data_slot,
+            allocation_callbacks.as_raw_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSetPrivateDataEXT.html>
+    #[inline]
+    pub unsafe fn set_private_data<T: vk::Handle>(
+        &self,
+        object: T,
+        private_data_slot: vk::PrivateDataSlotEXT,
+        data: u64,
+    ) -> VkResult<()> {
+        (self.fp.set_private_data_ext)(
+            self.handle,
+            T::TYPE,
+            object.as_raw(),
+            private_data_slot,
+            data,
+        )
+        .result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPrivateDataEXT.html>
+    #[inline]
+    pub unsafe fn get_private_data<T: vk::Handle>(
+        &self,
+        object: T,
+        private_data_slot: vk::PrivateDataSlotEXT,
+    ) -> u64 {
+        let mut data = mem::zeroed();
+        (self.fp.get_private_data_ext)(
+            self.handle,
+            T::TYPE,
+            object.as_raw(),
+            private_data_slot,
+            &mut data,
+        );
+        data
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtPrivateDataFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtPrivateDataFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/ext/sample_locations.rs b/src/extensions/ext/sample_locations.rs
new file mode 100644
index 0000000..360b83a
--- /dev/null
+++ b/src/extensions/ext/sample_locations.rs
@@ -0,0 +1,54 @@
+use crate::vk;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_EXT_sample_locations.html>
+#[derive(Clone)]
+pub struct SampleLocations {
+    fp: vk::ExtSampleLocationsFn,
+}
+
+impl SampleLocations {
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let fp = vk::ExtSampleLocationsFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html>
+    #[inline]
+    pub unsafe fn get_physical_device_multisample_properties(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        samples: vk::SampleCountFlags,
+        multisample_properties: &mut vk::MultisamplePropertiesEXT,
+    ) {
+        (self.fp.get_physical_device_multisample_properties_ext)(
+            physical_device,
+            samples,
+            multisample_properties,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleLocationsEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_sample_locations(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        sample_locations_info: &vk::SampleLocationsInfoEXT,
+    ) {
+        (self.fp.cmd_set_sample_locations_ext)(command_buffer, sample_locations_info)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtSampleLocationsFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtSampleLocationsFn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/ext/shader_object.rs b/src/extensions/ext/shader_object.rs
new file mode 100644
index 0000000..1b5ff3a
--- /dev/null
+++ b/src/extensions/ext/shader_object.rs
@@ -0,0 +1,719 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::RawPtr;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+use std::ptr;
+
+/// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VK_EXT_shader_object.html>
+#[derive(Clone)]
+pub struct ShaderObject {
+    handle: vk::Device,
+    fp: vk::ExtShaderObjectFn,
+}
+
+impl ShaderObject {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::ExtShaderObjectFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateShadersEXT.html>
+    #[inline]
+    pub unsafe fn create_shaders(
+        &self,
+        create_infos: &[vk::ShaderCreateInfoEXT],
+        allocator: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<Vec<vk::ShaderEXT>> {
+        let mut shaders = Vec::with_capacity(create_infos.len());
+        (self.fp.create_shaders_ext)(
+            self.handle,
+            create_infos.len() as u32,
+            create_infos.as_ptr(),
+            allocator.as_raw_ptr(),
+            shaders.as_mut_ptr(),
+        )
+        .result()?;
+        shaders.set_len(create_infos.len());
+        Ok(shaders)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyShaderEXT.html>
+    #[inline]
+    pub unsafe fn destroy_shader(
+        &self,
+        shader: vk::ShaderEXT,
+        allocator: Option<&vk::AllocationCallbacks>,
+    ) {
+        (self.fp.destroy_shader_ext)(self.handle, shader, allocator.as_raw_ptr())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetShaderBinaryDataEXT.html>
+    #[inline]
+    pub unsafe fn get_shader_binary_data(&self, shader: vk::ShaderEXT) -> VkResult<Vec<u8>> {
+        read_into_uninitialized_vector(|count, data: *mut u8| {
+            (self.fp.get_shader_binary_data_ext)(self.handle, shader, count, data.cast())
+        })
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindShadersEXT.html>
+    #[inline]
+    pub unsafe fn cmd_bind_shaders(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        stages: &[vk::ShaderStageFlags],
+        shaders: &[vk::ShaderEXT],
+    ) {
+        assert_eq!(stages.len(), shaders.len());
+        (self.fp.cmd_bind_shaders_ext)(
+            command_buffer,
+            stages.len() as u32,
+            stages.as_ptr(),
+            shaders.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetVertexInputEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_vertex_input(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        vertex_binding_descriptions: &[vk::VertexInputBindingDescription2EXT],
+        vertex_attribute_descriptions: &[vk::VertexInputAttributeDescription2EXT],
+    ) {
+        (self.fp.cmd_set_vertex_input_ext)(
+            command_buffer,
+            vertex_binding_descriptions.len() as u32,
+            vertex_binding_descriptions.as_ptr(),
+            vertex_attribute_descriptions.len() as u32,
+            vertex_attribute_descriptions.as_ptr(),
+        )
+    }
+
+    // --- extended_dynamic_state functions ---
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCullModeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_cull_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        cull_mode: vk::CullModeFlags,
+    ) {
+        (self.fp.cmd_set_cull_mode_ext)(command_buffer, cull_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetFrontFaceEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_front_face(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        front_face: vk::FrontFace,
+    ) {
+        (self.fp.cmd_set_front_face_ext)(command_buffer, front_face)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveTopologyEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_primitive_topology(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        primitive_topology: vk::PrimitiveTopology,
+    ) {
+        (self.fp.cmd_set_primitive_topology_ext)(command_buffer, primitive_topology)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportWithCountEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_viewport_with_count(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        viewports: &[vk::Viewport],
+    ) {
+        (self.fp.cmd_set_viewport_with_count_ext)(
+            command_buffer,
+            viewports.len() as u32,
+            viewports.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetScissorWithCountEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_scissor_with_count(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        scissors: &[vk::Rect2D],
+    ) {
+        (self.fp.cmd_set_scissor_with_count_ext)(
+            command_buffer,
+            scissors.len() as u32,
+            scissors.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBindVertexBuffers2EXT.html>
+    #[inline]
+    pub unsafe fn cmd_bind_vertex_buffers2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_binding: u32,
+        buffers: &[vk::Buffer],
+        offsets: &[vk::DeviceSize],
+        sizes: Option<&[vk::DeviceSize]>,
+        strides: Option<&[vk::DeviceSize]>,
+    ) {
+        assert_eq!(offsets.len(), buffers.len());
+        let p_sizes = if let Some(sizes) = sizes {
+            assert_eq!(sizes.len(), buffers.len());
+            sizes.as_ptr()
+        } else {
+            ptr::null()
+        };
+        let p_strides = if let Some(strides) = strides {
+            assert_eq!(strides.len(), buffers.len());
+            strides.as_ptr()
+        } else {
+            ptr::null()
+        };
+        (self.fp.cmd_bind_vertex_buffers2_ext)(
+            command_buffer,
+            first_binding,
+            buffers.len() as u32,
+            buffers.as_ptr(),
+            offsets.as_ptr(),
+            p_sizes,
+            p_strides,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthTestEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_test_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_test_enable: bool,
+    ) {
+        (self.fp.cmd_set_depth_test_enable_ext)(command_buffer, depth_test_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthWriteEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_write_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_write_enable: bool,
+    ) {
+        (self.fp.cmd_set_depth_write_enable_ext)(command_buffer, depth_write_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthCompareOpEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_compare_op(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_compare_op: vk::CompareOp,
+    ) {
+        (self.fp.cmd_set_depth_compare_op_ext)(command_buffer, depth_compare_op)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBoundsTestEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_bounds_test_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_bounds_test_enable: bool,
+    ) {
+        (self.fp.cmd_set_depth_bounds_test_enable_ext)(
+            command_buffer,
+            depth_bounds_test_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilTestEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_stencil_test_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        stencil_test_enable: bool,
+    ) {
+        (self.fp.cmd_set_stencil_test_enable_ext)(command_buffer, stencil_test_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetStencilOpEXT.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,
+    ) {
+        (self.fp.cmd_set_stencil_op_ext)(
+            command_buffer,
+            face_mask,
+            fail_op,
+            pass_op,
+            depth_fail_op,
+            compare_op,
+        )
+    }
+
+    // --- extended_dynamic_state2 functions ---
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPatchControlPointsEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_patch_control_points(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        patch_control_points: u32,
+    ) {
+        (self.fp.cmd_set_patch_control_points_ext)(command_buffer, patch_control_points)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizerDiscardEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_rasterizer_discard_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        rasterizer_discard_enable: bool,
+    ) {
+        (self.fp.cmd_set_rasterizer_discard_enable_ext)(
+            command_buffer,
+            rasterizer_discard_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthBiasEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_bias_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_bias_enable: bool,
+    ) {
+        (self.fp.cmd_set_depth_bias_enable_ext)(command_buffer, depth_bias_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLogicOpEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_logic_op(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        logic_op: vk::LogicOp,
+    ) {
+        (self.fp.cmd_set_logic_op_ext)(command_buffer, logic_op)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPrimitiveRestartEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_primitive_restart_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        primitive_restart_enable: bool,
+    ) {
+        (self.fp.cmd_set_primitive_restart_enable_ext)(
+            command_buffer,
+            primitive_restart_enable.into(),
+        )
+    }
+
+    // --- extended_dynamic_state3 functions ---
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetTessellationDomainOriginEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_tessellation_domain_origin(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        domain_origin: vk::TessellationDomainOrigin,
+    ) {
+        (self.fp.cmd_set_tessellation_domain_origin_ext)(command_buffer, domain_origin)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClampEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_clamp_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_clamp_enable: bool,
+    ) {
+        (self.fp.cmd_set_depth_clamp_enable_ext)(command_buffer, depth_clamp_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetPolygonModeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_polygon_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        polygon_mode: vk::PolygonMode,
+    ) {
+        (self.fp.cmd_set_polygon_mode_ext)(command_buffer, polygon_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizationSamplesEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_rasterization_samples(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        rasterization_samples: vk::SampleCountFlags,
+    ) {
+        (self.fp.cmd_set_rasterization_samples_ext)(command_buffer, rasterization_samples)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleMaskEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_sample_mask(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        samples: vk::SampleCountFlags,
+        sample_mask: &[vk::SampleMask],
+    ) {
+        assert!(
+            samples.as_raw().is_power_of_two(),
+            "Only one SampleCount bit must be set"
+        );
+        assert_eq!(samples.as_raw() as usize / 32, sample_mask.len());
+        (self.fp.cmd_set_sample_mask_ext)(command_buffer, samples, sample_mask.as_ptr())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetAlphaToCoverageEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_alpha_to_coverage_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        alpha_to_coverage_enable: bool,
+    ) {
+        (self.fp.cmd_set_alpha_to_coverage_enable_ext)(
+            command_buffer,
+            alpha_to_coverage_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetAlphaToOneEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_alpha_to_one_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        alpha_to_one_enable: bool,
+    ) {
+        (self.fp.cmd_set_alpha_to_one_enable_ext)(command_buffer, alpha_to_one_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLogicOpEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_logic_op_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        logic_op_enable: bool,
+    ) {
+        (self.fp.cmd_set_logic_op_enable_ext)(command_buffer, logic_op_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_color_blend_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        color_blend_enables: &[vk::Bool32],
+    ) {
+        (self.fp.cmd_set_color_blend_enable_ext)(
+            command_buffer,
+            first_attachment,
+            color_blend_enables.len() as u32,
+            color_blend_enables.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendEquationEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_color_blend_equation(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        color_blend_equations: &[vk::ColorBlendEquationEXT],
+    ) {
+        (self.fp.cmd_set_color_blend_equation_ext)(
+            command_buffer,
+            first_attachment,
+            color_blend_equations.len() as u32,
+            color_blend_equations.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorWriteMaskEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_color_write_mask(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        color_write_masks: &[vk::ColorComponentFlags],
+    ) {
+        (self.fp.cmd_set_color_write_mask_ext)(
+            command_buffer,
+            first_attachment,
+            color_write_masks.len() as u32,
+            color_write_masks.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRasterizationStreamEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_rasterization_stream(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        rasterization_stream: u32,
+    ) {
+        (self.fp.cmd_set_rasterization_stream_ext)(command_buffer, rasterization_stream)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetConservativeRasterizationModeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_conservative_rasterization_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        conservative_rasterization_mode: vk::ConservativeRasterizationModeEXT,
+    ) {
+        (self.fp.cmd_set_conservative_rasterization_mode_ext)(
+            command_buffer,
+            conservative_rasterization_mode,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_extra_primitive_overestimation_size(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        extra_primitive_overestimation_size: f32,
+    ) {
+        (self.fp.cmd_set_extra_primitive_overestimation_size_ext)(
+            command_buffer,
+            extra_primitive_overestimation_size,
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClipEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_clip_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        depth_clip_enable: bool,
+    ) {
+        (self.fp.cmd_set_depth_clip_enable_ext)(command_buffer, depth_clip_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetSampleLocationsEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_sample_locations_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        sample_locations_enable: bool,
+    ) {
+        (self.fp.cmd_set_sample_locations_enable_ext)(
+            command_buffer,
+            sample_locations_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetColorBlendAdvancedEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_color_blend_advanced(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        color_blend_advanced: &[vk::ColorBlendAdvancedEXT],
+    ) {
+        (self.fp.cmd_set_color_blend_advanced_ext)(
+            command_buffer,
+            first_attachment,
+            color_blend_advanced.len() as u32,
+            color_blend_advanced.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetProvokingVertexModeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_provoking_vertex_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        provoking_vertex_mode: vk::ProvokingVertexModeEXT,
+    ) {
+        (self.fp.cmd_set_provoking_vertex_mode_ext)(command_buffer, provoking_vertex_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineRasterizationModeEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_line_rasterization_mode(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        line_rasterization_mode: vk::LineRasterizationModeEXT,
+    ) {
+        (self.fp.cmd_set_line_rasterization_mode_ext)(command_buffer, line_rasterization_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetLineStippleEnableEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_line_stipple_enable(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        stippled_line_enable: bool,
+    ) {
+        (self.fp.cmd_set_line_stipple_enable_ext)(command_buffer, stippled_line_enable.into())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html>
+    #[inline]
+    pub unsafe fn cmd_set_depth_clip_negative_one_to_one(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        negative_one_to_one: bool,
+    ) {
+        (self.fp.cmd_set_depth_clip_negative_one_to_one_ext)(
+            command_buffer,
+            negative_one_to_one.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportWScalingEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_viewport_w_scaling_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        viewport_w_scaling_enable: bool,
+    ) {
+        (self.fp.cmd_set_viewport_w_scaling_enable_nv)(
+            command_buffer,
+            viewport_w_scaling_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetViewportSwizzleNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_viewport_swizzle_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        first_attachment: u32,
+        viewport_swizzles: &[vk::ViewportSwizzleNV],
+    ) {
+        (self.fp.cmd_set_viewport_swizzle_nv)(
+            command_buffer,
+            first_attachment,
+            viewport_swizzles.len() as u32,
+            viewport_swizzles.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageToColorEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_to_color_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_to_color_enable: bool,
+    ) {
+        (self.fp.cmd_set_coverage_to_color_enable_nv)(
+            command_buffer,
+            coverage_to_color_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageToColorLocationNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_to_color_location_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_to_color_location: u32,
+    ) {
+        (self.fp.cmd_set_coverage_to_color_location_nv)(command_buffer, coverage_to_color_location)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationModeNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_modulation_mode_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_modulation_mode: vk::CoverageModulationModeNV,
+    ) {
+        (self.fp.cmd_set_coverage_modulation_mode_nv)(command_buffer, coverage_modulation_mode)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationTableEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_modulation_table_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_modulation_table_enable: bool,
+    ) {
+        (self.fp.cmd_set_coverage_modulation_table_enable_nv)(
+            command_buffer,
+            coverage_modulation_table_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageModulationTableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_modulation_table_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_modulation_table: &[f32],
+    ) {
+        (self.fp.cmd_set_coverage_modulation_table_nv)(
+            command_buffer,
+            coverage_modulation_table.len() as u32,
+            coverage_modulation_table.as_ptr(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetShadingRateImageEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_shading_rate_image_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        shading_rate_image_enable: bool,
+    ) {
+        (self.fp.cmd_set_shading_rate_image_enable_nv)(
+            command_buffer,
+            shading_rate_image_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_representative_fragment_test_enable_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        representative_fragment_test_enable: bool,
+    ) {
+        (self.fp.cmd_set_representative_fragment_test_enable_nv)(
+            command_buffer,
+            representative_fragment_test_enable.into(),
+        )
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCoverageReductionModeNV.html>
+    #[inline]
+    pub unsafe fn cmd_set_coverage_reduction_mode_nv(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        coverage_reduction_mode: vk::CoverageReductionModeNV,
+    ) {
+        (self.fp.cmd_set_coverage_reduction_mode_nv)(command_buffer, coverage_reduction_mode)
+    }
+
+    pub const fn name() -> &'static CStr {
+        vk::ExtShaderObjectFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtShaderObjectFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/ext/tooling_info.rs b/src/extensions/ext/tooling_info.rs
index 284a472..fd4bf99 100644
--- a/src/extensions/ext/tooling_info.rs
+++ b/src/extensions/ext/tooling_info.rs
@@ -1,46 +1,40 @@
 use crate::prelude::*;
 use crate::vk;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct ToolingInfo {
-    handle: vk::Instance,
-    tooling_info_fn: vk::ExtToolingInfoFn,
+    fp: vk::ExtToolingInfoFn,
 }
 
 impl ToolingInfo {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let tooling_info_fn = vk::ExtToolingInfoFn::load(|name| unsafe {
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let fp = vk::ExtToolingInfoFn::load(|name| unsafe {
             mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            tooling_info_fn,
-        }
+        Self { fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::ExtToolingInfoFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html>
+    #[inline]
     pub unsafe fn get_physical_device_tool_properties(
         &self,
         physical_device: vk::PhysicalDevice,
     ) -> VkResult<Vec<vk::PhysicalDeviceToolPropertiesEXT>> {
         read_into_defaulted_vector(|count, data| {
-            self.tooling_info_fn
-                .get_physical_device_tool_properties_ext(physical_device, count, data)
+            (self.fp.get_physical_device_tool_properties_ext)(physical_device, count, data)
         })
     }
 
-    pub fn fp(&self) -> &vk::ExtToolingInfoFn {
-        &self.tooling_info_fn
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::ExtToolingInfoFn::name()
     }
 
-    pub fn instance(&self) -> vk::Instance {
-        self.handle
+    #[inline]
+    pub fn fp(&self) -> &vk::ExtToolingInfoFn {
+        &self.fp
     }
 }
diff --git a/src/extensions/khr/acceleration_structure.rs b/src/extensions/khr/acceleration_structure.rs
index 0e5c46e..9772e9b 100644
--- a/src/extensions/khr/acceleration_structure.rs
+++ b/src/extensions/khr/acceleration_structure.rs
@@ -8,20 +8,19 @@ use std::mem;
 #[derive(Clone)]
 pub struct AccelerationStructure {
     handle: vk::Device,
-    acceleration_structure_fn: vk::KhrAccelerationStructureFn,
+    fp: vk::KhrAccelerationStructureFn,
 }
 
 impl AccelerationStructure {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let acceleration_structure_fn = vk::KhrAccelerationStructureFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrAccelerationStructureFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            acceleration_structure_fn,
-        }
+        Self { handle, fp }
     }
 
+    #[inline]
     pub unsafe fn get_properties(
         instance: &Instance,
         pdevice: vk::PhysicalDevice,
@@ -34,38 +33,39 @@ impl AccelerationStructure {
         props_rt
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateAccelerationStructureKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateAccelerationStructureKHR.html>
+    #[inline]
     pub unsafe fn create_acceleration_structure(
         &self,
         create_info: &vk::AccelerationStructureCreateInfoKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::AccelerationStructureKHR> {
         let mut accel_struct = mem::zeroed();
-        self.acceleration_structure_fn
-            .create_acceleration_structure_khr(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut accel_struct,
-            )
-            .result_with_success(accel_struct)
+        (self.fp.create_acceleration_structure_khr)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut accel_struct,
+        )
+        .result_with_success(accel_struct)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyAccelerationStructureKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyAccelerationStructureKHR.html>
+    #[inline]
     pub unsafe fn destroy_acceleration_structure(
         &self,
         accel_struct: vk::AccelerationStructureKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.acceleration_structure_fn
-            .destroy_acceleration_structure_khr(
-                self.handle,
-                accel_struct,
-                allocation_callbacks.as_raw_ptr(),
-            );
+        (self.fp.destroy_acceleration_structure_khr)(
+            self.handle,
+            accel_struct,
+            allocation_callbacks.as_raw_ptr(),
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBuildAccelerationStructuresKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBuildAccelerationStructuresKHR.html>
+    #[inline]
     pub unsafe fn cmd_build_acceleration_structures(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -83,16 +83,16 @@ impl AccelerationStructure {
             })
             .collect::<Vec<_>>();
 
-        self.acceleration_structure_fn
-            .cmd_build_acceleration_structures_khr(
-                command_buffer,
-                infos.len() as _,
-                infos.as_ptr(),
-                build_range_infos.as_ptr(),
-            );
+        (self.fp.cmd_build_acceleration_structures_khr)(
+            command_buffer,
+            infos.len() as _,
+            infos.as_ptr(),
+            build_range_infos.as_ptr(),
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html>
+    #[inline]
     pub unsafe fn cmd_build_acceleration_structures_indirect(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -114,18 +114,18 @@ impl AccelerationStructure {
             })
             .collect::<Vec<_>>();
 
-        self.acceleration_structure_fn
-            .cmd_build_acceleration_structures_indirect_khr(
-                command_buffer,
-                infos.len() as _,
-                infos.as_ptr(),
-                indirect_device_addresses.as_ptr(),
-                indirect_strides.as_ptr(),
-                max_primitive_counts.as_ptr(),
-            );
+        (self.fp.cmd_build_acceleration_structures_indirect_khr)(
+            command_buffer,
+            infos.len() as _,
+            infos.as_ptr(),
+            indirect_device_addresses.as_ptr(),
+            indirect_strides.as_ptr(),
+            max_primitive_counts.as_ptr(),
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBuildAccelerationStructuresKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBuildAccelerationStructuresKHR.html>
+    #[inline]
     pub unsafe fn build_acceleration_structures(
         &self,
         deferred_operation: vk::DeferredOperationKHR,
@@ -143,59 +143,50 @@ impl AccelerationStructure {
             })
             .collect::<Vec<_>>();
 
-        self.acceleration_structure_fn
-            .build_acceleration_structures_khr(
-                self.handle,
-                deferred_operation,
-                infos.len() as _,
-                infos.as_ptr(),
-                build_range_infos.as_ptr(),
-            )
-            .into()
+        (self.fp.build_acceleration_structures_khr)(
+            self.handle,
+            deferred_operation,
+            infos.len() as _,
+            infos.as_ptr(),
+            build_range_infos.as_ptr(),
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCopyAccelerationStructureKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCopyAccelerationStructureKHR.html>
+    #[inline]
     pub unsafe fn copy_acceleration_structure(
         &self,
         deferred_operation: vk::DeferredOperationKHR,
         info: &vk::CopyAccelerationStructureInfoKHR,
     ) -> VkResult<()> {
-        self.acceleration_structure_fn
-            .copy_acceleration_structure_khr(self.handle, deferred_operation, info as *const _)
-            .into()
+        (self.fp.copy_acceleration_structure_khr)(self.handle, deferred_operation, info).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCopyAccelerationStructureToMemoryKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCopyAccelerationStructureToMemoryKHR.html>
+    #[inline]
     pub unsafe fn copy_acceleration_structure_to_memory(
         &self,
         deferred_operation: vk::DeferredOperationKHR,
         info: &vk::CopyAccelerationStructureToMemoryInfoKHR,
     ) -> VkResult<()> {
-        self.acceleration_structure_fn
-            .copy_acceleration_structure_to_memory_khr(
-                self.handle,
-                deferred_operation,
-                info as *const _,
-            )
-            .into()
+        (self.fp.copy_acceleration_structure_to_memory_khr)(self.handle, deferred_operation, info)
+            .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCopyMemoryToAccelerationStructureKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCopyMemoryToAccelerationStructureKHR.html>
+    #[inline]
     pub unsafe fn copy_memory_to_acceleration_structure(
         &self,
         deferred_operation: vk::DeferredOperationKHR,
         info: &vk::CopyMemoryToAccelerationStructureInfoKHR,
     ) -> VkResult<()> {
-        self.acceleration_structure_fn
-            .copy_memory_to_acceleration_structure_khr(
-                self.handle,
-                deferred_operation,
-                info as *const _,
-            )
-            .into()
+        (self.fp.copy_memory_to_acceleration_structure_khr)(self.handle, deferred_operation, info)
+            .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWriteAccelerationStructuresPropertiesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkWriteAccelerationStructuresPropertiesKHR.html>
+    #[inline]
     pub unsafe fn write_acceleration_structures_properties(
         &self,
         acceleration_structures: &[vk::AccelerationStructureKHR],
@@ -203,59 +194,59 @@ impl AccelerationStructure {
         data: &mut [u8],
         stride: usize,
     ) -> VkResult<()> {
-        self.acceleration_structure_fn
-            .write_acceleration_structures_properties_khr(
-                self.handle,
-                acceleration_structures.len() as _,
-                acceleration_structures.as_ptr(),
-                query_type,
-                data.len(),
-                data.as_mut_ptr() as *mut std::ffi::c_void,
-                stride,
-            )
-            .into()
+        (self.fp.write_acceleration_structures_properties_khr)(
+            self.handle,
+            acceleration_structures.len() as _,
+            acceleration_structures.as_ptr(),
+            query_type,
+            data.len(),
+            data.as_mut_ptr().cast(),
+            stride,
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyAccelerationStructureKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyAccelerationStructureKHR.html>
+    #[inline]
     pub unsafe fn cmd_copy_acceleration_structure(
         &self,
         command_buffer: vk::CommandBuffer,
         info: &vk::CopyAccelerationStructureInfoKHR,
     ) {
-        self.acceleration_structure_fn
-            .cmd_copy_acceleration_structure_khr(command_buffer, info);
+        (self.fp.cmd_copy_acceleration_structure_khr)(command_buffer, info);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html>
+    #[inline]
     pub unsafe fn cmd_copy_acceleration_structure_to_memory(
         &self,
         command_buffer: vk::CommandBuffer,
         info: &vk::CopyAccelerationStructureToMemoryInfoKHR,
     ) {
-        self.acceleration_structure_fn
-            .cmd_copy_acceleration_structure_to_memory_khr(command_buffer, info as *const _);
+        (self.fp.cmd_copy_acceleration_structure_to_memory_khr)(command_buffer, info);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html>
+    #[inline]
     pub unsafe fn cmd_copy_memory_to_acceleration_structure(
         &self,
         command_buffer: vk::CommandBuffer,
         info: &vk::CopyMemoryToAccelerationStructureInfoKHR,
     ) {
-        self.acceleration_structure_fn
-            .cmd_copy_memory_to_acceleration_structure_khr(command_buffer, info as *const _);
+        (self.fp.cmd_copy_memory_to_acceleration_structure_khr)(command_buffer, info);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetAccelerationStructureHandleKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureHandleKHR.html>
+    #[inline]
     pub unsafe fn get_acceleration_structure_device_address(
         &self,
         info: &vk::AccelerationStructureDeviceAddressInfoKHR,
     ) -> vk::DeviceAddress {
-        self.acceleration_structure_fn
-            .get_acceleration_structure_device_address_khr(self.handle, info as *const _)
+        (self.fp.get_acceleration_structure_device_address_khr)(self.handle, info)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html>
+    #[inline]
     pub unsafe fn cmd_write_acceleration_structures_properties(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -264,35 +255,35 @@ impl AccelerationStructure {
         query_pool: vk::QueryPool,
         first_query: u32,
     ) {
-        self.acceleration_structure_fn
-            .cmd_write_acceleration_structures_properties_khr(
-                command_buffer,
-                structures.len() as _,
-                structures.as_ptr(),
-                query_type,
-                query_pool,
-                first_query,
-            );
+        (self.fp.cmd_write_acceleration_structures_properties_khr)(
+            command_buffer,
+            structures.len() as _,
+            structures.as_ptr(),
+            query_type,
+            query_pool,
+            first_query,
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html>
+    #[inline]
     pub unsafe fn get_device_acceleration_structure_compatibility(
         &self,
         version: &vk::AccelerationStructureVersionInfoKHR,
     ) -> vk::AccelerationStructureCompatibilityKHR {
         let mut compatibility = vk::AccelerationStructureCompatibilityKHR::default();
 
-        self.acceleration_structure_fn
-            .get_device_acceleration_structure_compatibility_khr(
-                self.handle,
-                version,
-                &mut compatibility as *mut _,
-            );
+        (self.fp.get_device_acceleration_structure_compatibility_khr)(
+            self.handle,
+            version,
+            &mut compatibility,
+        );
 
         compatibility
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetAccelerationStructureBuildSizesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureBuildSizesKHR.html>
+    #[inline]
     pub unsafe fn get_acceleration_structure_build_sizes(
         &self,
         build_type: vk::AccelerationStructureBuildTypeKHR,
@@ -303,26 +294,28 @@ impl AccelerationStructure {
 
         let mut size_info = vk::AccelerationStructureBuildSizesInfoKHR::default();
 
-        self.acceleration_structure_fn
-            .get_acceleration_structure_build_sizes_khr(
-                self.handle,
-                build_type,
-                build_info as *const _,
-                max_primitive_counts.as_ptr(),
-                &mut size_info as *mut _,
-            );
+        (self.fp.get_acceleration_structure_build_sizes_khr)(
+            self.handle,
+            build_type,
+            build_info,
+            max_primitive_counts.as_ptr(),
+            &mut size_info,
+        );
 
         size_info
     }
 
-    pub fn name() -> &'static CStr {
+    #[inline]
+    pub const fn name() -> &'static CStr {
         vk::KhrAccelerationStructureFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrAccelerationStructureFn {
-        &self.acceleration_structure_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/android_surface.rs b/src/extensions/khr/android_surface.rs
index fef6b7d..071d367 100755
--- a/src/extensions/khr/android_surface.rs
+++ b/src/extensions/khr/android_surface.rs
@@ -1,52 +1,53 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct AndroidSurface {
     handle: vk::Instance,
-    android_surface_fn: vk::KhrAndroidSurfaceFn,
+    fp: vk::KhrAndroidSurfaceFn,
 }
 
 impl AndroidSurface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::KhrAndroidSurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrAndroidSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            android_surface_fn: surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrAndroidSurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateAndroidSurfaceKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateAndroidSurfaceKHR.html>
+    #[inline]
     pub unsafe fn create_android_surface(
         &self,
         create_info: &vk::AndroidSurfaceCreateInfoKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        self.android_surface_fn
-            .create_android_surface_khr(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut surface,
-            )
-            .result_with_success(surface)
+        (self.fp.create_android_surface_khr)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrAndroidSurfaceFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrAndroidSurfaceFn {
-        &self.android_surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/khr/buffer_device_address.rs b/src/extensions/khr/buffer_device_address.rs
index 382df45..65eae69 100644
--- a/src/extensions/khr/buffer_device_address.rs
+++ b/src/extensions/khr/buffer_device_address.rs
@@ -6,54 +6,56 @@ use std::mem;
 #[derive(Clone)]
 pub struct BufferDeviceAddress {
     handle: vk::Device,
-    fns: vk::KhrBufferDeviceAddressFn,
+    fp: vk::KhrBufferDeviceAddressFn,
 }
 
 impl BufferDeviceAddress {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let fns = vk::KhrBufferDeviceAddressFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrBufferDeviceAddressFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            fns,
-        }
+        Self { handle, fp }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferDeviceAddressKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferDeviceAddressKHR.html>
+    #[inline]
     pub unsafe fn get_buffer_device_address(
         &self,
         info: &vk::BufferDeviceAddressInfoKHR,
     ) -> vk::DeviceAddress {
-        self.fns.get_buffer_device_address_khr(self.handle, info)
+        (self.fp.get_buffer_device_address_khr)(self.handle, info)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferOpaqueCaptureAddressKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferOpaqueCaptureAddressKHR.html>
+    #[inline]
     pub unsafe fn get_buffer_opaque_capture_address(
         &self,
         info: &vk::BufferDeviceAddressInfoKHR,
     ) -> u64 {
-        self.fns
-            .get_buffer_opaque_capture_address_khr(self.handle, info)
+        (self.fp.get_buffer_opaque_capture_address_khr)(self.handle, info)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html>
+    #[inline]
     pub unsafe fn get_device_memory_opaque_capture_address(
         &self,
         info: &vk::DeviceMemoryOpaqueCaptureAddressInfoKHR,
     ) -> u64 {
-        self.fns
-            .get_device_memory_opaque_capture_address_khr(self.handle, info)
+        (self.fp.get_device_memory_opaque_capture_address_khr)(self.handle, info)
     }
 
-    pub fn name() -> &'static CStr {
+    #[inline]
+    pub const fn name() -> &'static CStr {
         vk::KhrBufferDeviceAddressFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrBufferDeviceAddressFn {
-        &self.fns
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/copy_commands2.rs b/src/extensions/khr/copy_commands2.rs
new file mode 100644
index 0000000..b465930
--- /dev/null
+++ b/src/extensions/khr/copy_commands2.rs
@@ -0,0 +1,84 @@
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_copy_commands2.html>
+#[derive(Clone)]
+pub struct CopyCommands2 {
+    fp: vk::KhrCopyCommands2Fn,
+}
+
+impl CopyCommands2 {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let fp = vk::KhrCopyCommands2Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyBuffer2KHR.html>
+    #[inline]
+    pub unsafe fn cmd_copy_buffer2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        copy_buffer_info: &vk::CopyBufferInfo2KHR,
+    ) {
+        (self.fp.cmd_copy_buffer2_khr)(command_buffer, copy_buffer_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyImage2KHR.html>
+    #[inline]
+    pub unsafe fn cmd_copy_image2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        copy_image_info: &vk::CopyImageInfo2KHR,
+    ) {
+        (self.fp.cmd_copy_image2_khr)(command_buffer, copy_image_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyBufferToImage2KHR.html>
+    #[inline]
+    pub unsafe fn cmd_copy_buffer_to_image2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        copy_buffer_to_image_info: &vk::CopyBufferToImageInfo2KHR,
+    ) {
+        (self.fp.cmd_copy_buffer_to_image2_khr)(command_buffer, copy_buffer_to_image_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyImageToBuffer2KHR.html>
+    #[inline]
+    pub unsafe fn cmd_copy_image_to_buffer2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        copy_image_to_buffer_info: &vk::CopyImageToBufferInfo2KHR,
+    ) {
+        (self.fp.cmd_copy_image_to_buffer2_khr)(command_buffer, copy_image_to_buffer_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBlitImage2KHR.html>
+    #[inline]
+    pub unsafe fn cmd_blit_image2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        blit_image_info: &vk::BlitImageInfo2KHR,
+    ) {
+        (self.fp.cmd_blit_image2_khr)(command_buffer, blit_image_info)
+    }
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdResolveImage2KHR.html>
+    #[inline]
+    pub unsafe fn cmd_resolve_image2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        resolve_image_info: &vk::ResolveImageInfo2KHR,
+    ) {
+        (self.fp.cmd_resolve_image2_khr)(command_buffer, resolve_image_info)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrCopyCommands2Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrCopyCommands2Fn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/khr/create_render_pass2.rs b/src/extensions/khr/create_render_pass2.rs
index 09e1a4c..bf78bc5 100644
--- a/src/extensions/khr/create_render_pass2.rs
+++ b/src/extensions/khr/create_render_pass2.rs
@@ -8,83 +8,82 @@ use std::mem;
 #[derive(Clone)]
 pub struct CreateRenderPass2 {
     handle: vk::Device,
-    khr_create_renderpass2_fn: vk::KhrCreateRenderpass2Fn,
+    fp: vk::KhrCreateRenderpass2Fn,
 }
 
 impl CreateRenderPass2 {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let khr_create_renderpass2_fn = vk::KhrCreateRenderpass2Fn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrCreateRenderpass2Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            khr_create_renderpass2_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrCreateRenderpass2Fn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateRenderPass2.html>
+    #[inline]
     pub unsafe fn create_render_pass2(
         &self,
         create_info: &vk::RenderPassCreateInfo2,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::RenderPass> {
         let mut renderpass = mem::zeroed();
-        self.khr_create_renderpass2_fn
-            .create_render_pass2_khr(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut renderpass,
-            )
-            .result_with_success(renderpass)
+        (self.fp.create_render_pass2_khr)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut renderpass,
+        )
+        .result_with_success(renderpass)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginRenderPass2.html>
+    #[inline]
     pub unsafe fn cmd_begin_render_pass2(
         &self,
         command_buffer: vk::CommandBuffer,
         render_pass_begin_info: &vk::RenderPassBeginInfo,
         subpass_begin_info: &vk::SubpassBeginInfo,
     ) {
-        self.khr_create_renderpass2_fn.cmd_begin_render_pass2_khr(
+        (self.fp.cmd_begin_render_pass2_khr)(
             command_buffer,
             render_pass_begin_info,
             subpass_begin_info,
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdNextSubpass2.html>
+    #[inline]
     pub unsafe fn cmd_next_subpass2(
         &self,
         command_buffer: vk::CommandBuffer,
         subpass_begin_info: &vk::SubpassBeginInfo,
         subpass_end_info: &vk::SubpassEndInfo,
     ) {
-        self.khr_create_renderpass2_fn.cmd_next_subpass2_khr(
-            command_buffer,
-            subpass_begin_info,
-            subpass_end_info,
-        );
+        (self.fp.cmd_next_subpass2_khr)(command_buffer, subpass_begin_info, subpass_end_info);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndRenderPass2.html>
+    #[inline]
     pub unsafe fn cmd_end_render_pass2(
         &self,
         command_buffer: vk::CommandBuffer,
         subpass_end_info: &vk::SubpassEndInfo,
     ) {
-        self.khr_create_renderpass2_fn
-            .cmd_end_render_pass2_khr(command_buffer, subpass_end_info);
+        (self.fp.cmd_end_render_pass2_khr)(command_buffer, subpass_end_info);
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrCreateRenderpass2Fn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrCreateRenderpass2Fn {
-        &self.khr_create_renderpass2_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/deferred_host_operations.rs b/src/extensions/khr/deferred_host_operations.rs
index d4b2c3d..51aeaad 100644
--- a/src/extensions/khr/deferred_host_operations.rs
+++ b/src/extensions/khr/deferred_host_operations.rs
@@ -8,86 +8,85 @@ use std::mem;
 #[derive(Clone)]
 pub struct DeferredHostOperations {
     handle: vk::Device,
-    deferred_host_operations_fn: vk::KhrDeferredHostOperationsFn,
+    fp: vk::KhrDeferredHostOperationsFn,
 }
 
 impl DeferredHostOperations {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let deferred_host_operations_fn = vk::KhrDeferredHostOperationsFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrDeferredHostOperationsFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            deferred_host_operations_fn,
-        }
+        Self { handle, fp }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDeferredOperationKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDeferredOperationKHR.html>
+    #[inline]
     pub unsafe fn create_deferred_operation(
         &self,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DeferredOperationKHR> {
         let mut operation = mem::zeroed();
-        self.deferred_host_operations_fn
-            .create_deferred_operation_khr(
-                self.handle,
-                allocation_callbacks.as_raw_ptr(),
-                &mut operation,
-            )
-            .result_with_success(operation)
+        (self.fp.create_deferred_operation_khr)(
+            self.handle,
+            allocation_callbacks.as_raw_ptr(),
+            &mut operation,
+        )
+        .result_with_success(operation)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDeferredOperationJoinKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDeferredOperationJoinKHR.html>
+    #[inline]
     pub unsafe fn deferred_operation_join(
         &self,
         operation: vk::DeferredOperationKHR,
     ) -> VkResult<()> {
-        self.deferred_host_operations_fn
-            .deferred_operation_join_khr(self.handle, operation)
-            .result()
+        (self.fp.deferred_operation_join_khr)(self.handle, operation).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDeferredOperationKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyDeferredOperationKHR.html>
+    #[inline]
     pub unsafe fn destroy_deferred_operation(
         &self,
         operation: vk::DeferredOperationKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.deferred_host_operations_fn
-            .destroy_deferred_operation_khr(
-                self.handle,
-                operation,
-                allocation_callbacks.as_raw_ptr(),
-            );
+        (self.fp.destroy_deferred_operation_khr)(
+            self.handle,
+            operation,
+            allocation_callbacks.as_raw_ptr(),
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html>
+    #[inline]
     pub unsafe fn get_deferred_operation_max_concurrency(
         &self,
         operation: vk::DeferredOperationKHR,
     ) -> u32 {
-        self.deferred_host_operations_fn
-            .get_deferred_operation_max_concurrency_khr(self.handle, operation)
+        (self.fp.get_deferred_operation_max_concurrency_khr)(self.handle, operation)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeferredOperationResultKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeferredOperationResultKHR.html>
+    #[inline]
     pub unsafe fn get_deferred_operation_result(
         &self,
         operation: vk::DeferredOperationKHR,
     ) -> VkResult<()> {
-        self.deferred_host_operations_fn
-            .get_deferred_operation_result_khr(self.handle, operation)
-            .result()
+        (self.fp.get_deferred_operation_result_khr)(self.handle, operation).result()
     }
 
-    pub fn name() -> &'static CStr {
+    #[inline]
+    pub const fn name() -> &'static CStr {
         vk::KhrDeferredHostOperationsFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrDeferredHostOperationsFn {
-        &self.deferred_host_operations_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/device_group.rs b/src/extensions/khr/device_group.rs
new file mode 100644
index 0000000..6863b83
--- /dev/null
+++ b/src/extensions/khr/device_group.rs
@@ -0,0 +1,193 @@
+#[cfg(doc)]
+use super::Swapchain;
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_device_group.html>
+#[derive(Clone)]
+pub struct DeviceGroup {
+    handle: vk::Device,
+    fp: vk::KhrDeviceGroupFn,
+}
+
+impl DeviceGroup {
+    /// # Warning
+    /// [`Instance`] functions cannot be loaded from a [`Device`] and will always panic when called:
+    /// - [`Self::get_physical_device_present_rectangles()`]
+    ///
+    /// Load this struct using an [`Instance`] instead via [`Self::new_from_instance()`] if the
+    /// above [`Instance`] function is called. This will be solved in the next breaking `ash`
+    /// release: <https://github.com/ash-rs/ash/issues/727>.
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::KhrDeviceGroupFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// Loads all functions on the [`Instance`] instead of [`Device`]. This incurs an extra
+    /// dispatch table for [`Device`] functions but also allows the [`Instance`] function to be
+    /// loaded instead of always panicking. See also [`Self::new()`] for more details.
+    ///
+    /// It is okay to pass [`vk::Device::null()`] when this struct is only used to call the
+    /// [`Instance`] function.
+    pub fn new_from_instance(entry: &Entry, instance: &Instance, device: vk::Device) -> Self {
+        let fp = vk::KhrDeviceGroupFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { handle: device, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html>
+    #[inline]
+    pub unsafe fn get_device_group_peer_memory_features(
+        &self,
+        heap_index: u32,
+        local_device_index: u32,
+        remote_device_index: u32,
+    ) -> vk::PeerMemoryFeatureFlags {
+        let mut peer_memory_features = mem::zeroed();
+        (self.fp.get_device_group_peer_memory_features_khr)(
+            self.handle,
+            heap_index,
+            local_device_index,
+            remote_device_index,
+            &mut peer_memory_features,
+        );
+        peer_memory_features
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetDeviceMaskKHR.html>
+    #[inline]
+    pub unsafe fn cmd_set_device_mask(&self, command_buffer: vk::CommandBuffer, device_mask: u32) {
+        (self.fp.cmd_set_device_mask_khr)(command_buffer, device_mask)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDispatchBaseKHR.html>
+    #[inline]
+    pub unsafe fn cmd_dispatch_base(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        base_group: (u32, u32, u32),
+        group_count: (u32, u32, u32),
+    ) {
+        (self.fp.cmd_dispatch_base_khr)(
+            command_buffer,
+            base_group.0,
+            base_group.1,
+            base_group.2,
+            group_count.0,
+            group_count.1,
+            group_count.2,
+        )
+    }
+
+    /// Requires [`VK_KHR_surface`] to be enabled.
+    ///
+    /// Also available as [`Swapchain::get_device_group_present_capabilities()`] since [Vulkan 1.1].
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html>
+    ///
+    /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html
+    /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html
+    #[inline]
+    pub unsafe fn get_device_group_present_capabilities(
+        &self,
+        device_group_present_capabilities: &mut vk::DeviceGroupPresentCapabilitiesKHR,
+    ) -> VkResult<()> {
+        (self.fp.get_device_group_present_capabilities_khr)(
+            self.handle,
+            device_group_present_capabilities,
+        )
+        .result()
+    }
+
+    /// Requires [`VK_KHR_surface`] to be enabled.
+    ///
+    /// Also available as [`Swapchain::get_device_group_surface_present_modes()`] since [Vulkan 1.1].
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html>
+    ///
+    /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html
+    /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html
+    #[inline]
+    pub unsafe fn get_device_group_surface_present_modes(
+        &self,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<vk::DeviceGroupPresentModeFlagsKHR> {
+        let mut modes = mem::zeroed();
+        (self.fp.get_device_group_surface_present_modes_khr)(self.handle, surface, &mut modes)
+            .result_with_success(modes)
+    }
+
+    /// Requires [`VK_KHR_surface`] to be enabled.
+    ///
+    /// Also available as [`Swapchain::get_physical_device_present_rectangles()`] since [Vulkan 1.1].
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html>
+    ///
+    /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html
+    /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html
+    ///
+    /// # Warning
+    ///
+    /// Function will always panic unless this struct is loaded via [`Self::new_from_instance()`].
+    #[inline]
+    pub unsafe fn get_physical_device_present_rectangles(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<Vec<vk::Rect2D>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_physical_device_present_rectangles_khr)(
+                physical_device,
+                surface,
+                count,
+                data,
+            )
+        })
+    }
+
+    /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface.
+    ///
+    /// Requires [`VK_KHR_swapchain`] to be enabled.
+    ///
+    /// Also available as [`Swapchain::acquire_next_image2()`] since [Vulkan 1.1].
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireNextImage2KHR.html>
+    ///
+    /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html
+    /// [`VK_KHR_swapchain`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html
+    #[inline]
+    pub unsafe fn acquire_next_image2(
+        &self,
+        acquire_info: &vk::AcquireNextImageInfoKHR,
+    ) -> VkResult<(u32, bool)> {
+        let mut index = 0;
+        let err_code = (self.fp.acquire_next_image2_khr)(self.handle, acquire_info, &mut index);
+        match err_code {
+            vk::Result::SUCCESS => Ok((index, false)),
+            vk::Result::SUBOPTIMAL_KHR => Ok((index, true)),
+            _ => Err(err_code),
+        }
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrDeviceGroupFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrDeviceGroupFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/khr/device_group_creation.rs b/src/extensions/khr/device_group_creation.rs
new file mode 100644
index 0000000..60f5f33
--- /dev/null
+++ b/src/extensions/khr/device_group_creation.rs
@@ -0,0 +1,72 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+use std::ptr;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_device_group_creation.html>
+#[derive(Clone)]
+pub struct DeviceGroupCreation {
+    handle: vk::Instance,
+    fp: vk::KhrDeviceGroupCreationFn,
+}
+
+impl DeviceGroupCreation {
+    pub fn new(entry: Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrDeviceGroupCreationFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// Retrieve the number of elements to pass to [`enumerate_physical_device_groups()`][Self::enumerate_physical_device_groups()]
+    #[inline]
+    pub unsafe fn enumerate_physical_device_groups_len(&self) -> VkResult<usize> {
+        let mut group_count = 0;
+        (self.fp.enumerate_physical_device_groups_khr)(
+            self.handle,
+            &mut group_count,
+            ptr::null_mut(),
+        )
+        .result_with_success(group_count as usize)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html>
+    ///
+    /// Call [`enumerate_physical_device_groups_len()`][Self::enumerate_physical_device_groups_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn enumerate_physical_device_groups(
+        &self,
+        out: &mut [vk::PhysicalDeviceGroupProperties],
+    ) -> VkResult<()> {
+        let mut count = out.len() as u32;
+        (self.fp.enumerate_physical_device_groups_khr)(self.handle, &mut count, out.as_mut_ptr())
+            .result()?;
+        assert_eq!(count as usize, out.len());
+        Ok(())
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrDeviceGroupCreationFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrDeviceGroupCreationFn {
+        &self.fp
+    }
+
+    #[deprecated = "typo: this function is called `device()`, but returns an `Instance`."]
+    #[inline]
+    pub fn device(&self) -> vk::Instance {
+        self.handle
+    }
+
+    #[inline]
+    pub fn instance(&self) -> vk::Instance {
+        self.handle
+    }
+}
diff --git a/src/extensions/khr/display.rs b/src/extensions/khr/display.rs
index 4ae8a34..b71c9c1 100755
--- a/src/extensions/khr/display.rs
+++ b/src/extensions/khr/display.rs
@@ -1,61 +1,56 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct Display {
     handle: vk::Instance,
-    display_fn: vk::KhrDisplayFn,
+    fp: vk::KhrDisplayFn,
 }
 
 impl Display {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let display_fn = vk::KhrDisplayFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrDisplayFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            display_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrDisplayFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_display_properties(
         &self,
         physical_device: vk::PhysicalDevice,
     ) -> VkResult<Vec<vk::DisplayPropertiesKHR>> {
         read_into_uninitialized_vector(|count, data| {
-            self.display_fn
-                .get_physical_device_display_properties_khr(physical_device, count, data)
+            (self.fp.get_physical_device_display_properties_khr)(physical_device, count, data)
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_display_plane_properties(
         &self,
         physical_device: vk::PhysicalDevice,
     ) -> VkResult<Vec<vk::DisplayPlanePropertiesKHR>> {
         read_into_uninitialized_vector(|count, data| {
-            self.display_fn
-                .get_physical_device_display_plane_properties_khr(physical_device, count, data)
+            (self.fp.get_physical_device_display_plane_properties_khr)(physical_device, count, data)
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html>
+    #[inline]
     pub unsafe fn get_display_plane_supported_displays(
         &self,
         physical_device: vk::PhysicalDevice,
         plane_index: u32,
     ) -> VkResult<Vec<vk::DisplayKHR>> {
         read_into_uninitialized_vector(|count, data| {
-            self.display_fn.get_display_plane_supported_displays_khr(
+            (self.fp.get_display_plane_supported_displays_khr)(
                 physical_device,
                 plane_index,
                 count,
@@ -64,19 +59,20 @@ impl Display {
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayModePropertiesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDisplayModePropertiesKHR.html>
+    #[inline]
     pub unsafe fn get_display_mode_properties(
         &self,
         physical_device: vk::PhysicalDevice,
         display: vk::DisplayKHR,
     ) -> VkResult<Vec<vk::DisplayModePropertiesKHR>> {
         read_into_uninitialized_vector(|count, data| {
-            self.display_fn
-                .get_display_mode_properties_khr(physical_device, display, count, data)
+            (self.fp.get_display_mode_properties_khr)(physical_device, display, count, data)
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDisplayModeKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDisplayModeKHR.html>
+    #[inline]
     pub unsafe fn create_display_mode(
         &self,
         physical_device: vk::PhysicalDevice,
@@ -85,18 +81,18 @@ impl Display {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::DisplayModeKHR> {
         let mut display_mode = mem::MaybeUninit::zeroed();
-        self.display_fn
-            .create_display_mode_khr(
-                physical_device,
-                display,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                display_mode.as_mut_ptr(),
-            )
-            .result_with_success(display_mode.assume_init())
+        (self.fp.create_display_mode_khr)(
+            physical_device,
+            display,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            display_mode.as_mut_ptr(),
+        )
+        .assume_init_on_success(display_mode)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayPlaneCapabilitiesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDisplayPlaneCapabilitiesKHR.html>
+    #[inline]
     pub unsafe fn get_display_plane_capabilities(
         &self,
         physical_device: vk::PhysicalDevice,
@@ -104,37 +100,43 @@ impl Display {
         plane_index: u32,
     ) -> VkResult<vk::DisplayPlaneCapabilitiesKHR> {
         let mut display_plane_capabilities = mem::MaybeUninit::zeroed();
-        self.display_fn
-            .get_display_plane_capabilities_khr(
-                physical_device,
-                mode,
-                plane_index,
-                display_plane_capabilities.as_mut_ptr(),
-            )
-            .result_with_success(display_plane_capabilities.assume_init())
+        (self.fp.get_display_plane_capabilities_khr)(
+            physical_device,
+            mode,
+            plane_index,
+            display_plane_capabilities.as_mut_ptr(),
+        )
+        .assume_init_on_success(display_plane_capabilities)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDisplayPlaneSurfaceKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDisplayPlaneSurfaceKHR.html>
+    #[inline]
     pub unsafe fn create_display_plane_surface(
         &self,
         create_info: &vk::DisplaySurfaceCreateInfoKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::MaybeUninit::zeroed();
-        self.display_fn
-            .create_display_plane_surface_khr(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                surface.as_mut_ptr(),
-            )
-            .result_with_success(surface.assume_init())
+        (self.fp.create_display_plane_surface_khr)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            surface.as_mut_ptr(),
+        )
+        .assume_init_on_success(surface)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrDisplayFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrDisplayFn {
-        &self.display_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/khr/display_swapchain.rs b/src/extensions/khr/display_swapchain.rs
index ef8b975..e4a33b2 100755
--- a/src/extensions/khr/display_swapchain.rs
+++ b/src/extensions/khr/display_swapchain.rs
@@ -8,46 +8,49 @@ use std::mem;
 #[derive(Clone)]
 pub struct DisplaySwapchain {
     handle: vk::Device,
-    swapchain_fn: vk::KhrDisplaySwapchainFn,
+    fp: vk::KhrDisplaySwapchainFn,
 }
 
 impl DisplaySwapchain {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let swapchain_fn = vk::KhrDisplaySwapchainFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrDisplaySwapchainFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            swapchain_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrDisplaySwapchainFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSharedSwapchainsKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateSharedSwapchainsKHR.html>
+    #[inline]
     pub unsafe fn create_shared_swapchains(
         &self,
         create_infos: &[vk::SwapchainCreateInfoKHR],
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<Vec<vk::SwapchainKHR>> {
         let mut swapchains = Vec::with_capacity(create_infos.len());
-        let err_code = self.swapchain_fn.create_shared_swapchains_khr(
+        (self.fp.create_shared_swapchains_khr)(
             self.handle,
             create_infos.len() as u32,
             create_infos.as_ptr(),
             allocation_callbacks.as_raw_ptr(),
             swapchains.as_mut_ptr(),
-        );
+        )
+        .result()?;
         swapchains.set_len(create_infos.len());
-        err_code.result_with_success(swapchains)
+        Ok(swapchains)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrDisplaySwapchainFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrDisplaySwapchainFn {
-        &self.swapchain_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/draw_indirect_count.rs b/src/extensions/khr/draw_indirect_count.rs
index 2aa325a..f35ecbe 100644
--- a/src/extensions/khr/draw_indirect_count.rs
+++ b/src/extensions/khr/draw_indirect_count.rs
@@ -5,26 +5,19 @@ use std::mem;
 
 #[derive(Clone)]
 pub struct DrawIndirectCount {
-    handle: vk::Device,
-    draw_indirect_count_fn: vk::KhrDrawIndirectCountFn,
+    fp: vk::KhrDrawIndirectCountFn,
 }
 
 impl DrawIndirectCount {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let draw_indirect_count_fn = vk::KhrDrawIndirectCountFn::load(|name| unsafe {
+        let fp = vk::KhrDrawIndirectCountFn::load(|name| unsafe {
             mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            draw_indirect_count_fn,
-        }
+        Self { fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrDrawIndirectCountFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.1-extensions/man/html/vkCmdDrawIndexedIndirectCountKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawIndexedIndirectCountKHR.html>
+    #[inline]
     pub unsafe fn cmd_draw_indexed_indirect_count(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -35,19 +28,19 @@ impl DrawIndirectCount {
         max_draw_count: u32,
         stride: u32,
     ) {
-        self.draw_indirect_count_fn
-            .cmd_draw_indexed_indirect_count_khr(
-                command_buffer,
-                buffer,
-                offset,
-                count_buffer,
-                count_buffer_offset,
-                max_draw_count,
-                stride,
-            );
+        (self.fp.cmd_draw_indexed_indirect_count_khr)(
+            command_buffer,
+            buffer,
+            offset,
+            count_buffer,
+            count_buffer_offset,
+            max_draw_count,
+            stride,
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.1-extensions/man/html/vkCmdDrawIndirectCountKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawIndirectCountKHR.html>
+    #[inline]
     pub unsafe fn cmd_draw_indirect_count(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -58,15 +51,24 @@ impl DrawIndirectCount {
         max_draw_count: u32,
         stride: u32,
     ) {
-        self.draw_indirect_count_fn
-            .cmd_draw_indexed_indirect_count_khr(
-                command_buffer,
-                buffer,
-                offset,
-                count_buffer,
-                count_buffer_offset,
-                max_draw_count,
-                stride,
-            );
+        (self.fp.cmd_draw_indirect_count_khr)(
+            command_buffer,
+            buffer,
+            offset,
+            count_buffer,
+            count_buffer_offset,
+            max_draw_count,
+            stride,
+        );
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrDrawIndirectCountFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrDrawIndirectCountFn {
+        &self.fp
     }
 }
diff --git a/src/extensions/khr/dynamic_rendering.rs b/src/extensions/khr/dynamic_rendering.rs
new file mode 100644
index 0000000..ea6149a
--- /dev/null
+++ b/src/extensions/khr/dynamic_rendering.rs
@@ -0,0 +1,44 @@
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+#[derive(Clone)]
+pub struct DynamicRendering {
+    fp: vk::KhrDynamicRenderingFn,
+}
+
+impl DynamicRendering {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let fp = vk::KhrDynamicRenderingFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBeginRenderingKHR.html>
+    #[inline]
+    pub unsafe fn cmd_begin_rendering(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        rendering_info: &vk::RenderingInfoKHR,
+    ) {
+        (self.fp.cmd_begin_rendering_khr)(command_buffer, rendering_info)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdEndRenderingKHR.html>
+    #[inline]
+    pub unsafe fn cmd_end_rendering(&self, command_buffer: vk::CommandBuffer) {
+        (self.fp.cmd_end_rendering_khr)(command_buffer)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrDynamicRenderingFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrDynamicRenderingFn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/khr/external_fence_fd.rs b/src/extensions/khr/external_fence_fd.rs
index 246cc7e..6a3ec55 100644
--- a/src/extensions/khr/external_fence_fd.rs
+++ b/src/extensions/khr/external_fence_fd.rs
@@ -7,44 +7,42 @@ use std::mem;
 #[derive(Clone)]
 pub struct ExternalFenceFd {
     handle: vk::Device,
-    external_fence_fd_fn: vk::KhrExternalFenceFdFn,
+    fp: vk::KhrExternalFenceFdFn,
 }
 
 impl ExternalFenceFd {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let external_fence_fd_fn = vk::KhrExternalFenceFdFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrExternalFenceFdFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            external_fence_fd_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrExternalFenceFdFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkImportFenceFdKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportFenceFdKHR.html>
+    #[inline]
     pub unsafe fn import_fence_fd(&self, import_info: &vk::ImportFenceFdInfoKHR) -> VkResult<()> {
-        self.external_fence_fd_fn
-            .import_fence_fd_khr(self.handle, import_info)
-            .result()
+        (self.fp.import_fence_fd_khr)(self.handle, import_info).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetFenceFdKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetFenceFdKHR.html>
+    #[inline]
     pub unsafe fn get_fence_fd(&self, get_info: &vk::FenceGetFdInfoKHR) -> VkResult<i32> {
         let mut fd = -1;
+        (self.fp.get_fence_fd_khr)(self.handle, get_info, &mut fd).result_with_success(fd)
+    }
 
-        self.external_fence_fd_fn
-            .get_fence_fd_khr(self.handle, get_info, &mut fd)
-            .result_with_success(fd)
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrExternalFenceFdFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrExternalFenceFdFn {
-        &self.external_fence_fd_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/external_fence_win32.rs b/src/extensions/khr/external_fence_win32.rs
new file mode 100644
index 0000000..627bd1c
--- /dev/null
+++ b/src/extensions/khr/external_fence_win32.rs
@@ -0,0 +1,58 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+use std::ptr;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_fence_win32.html>
+#[derive(Clone)]
+pub struct ExternalFenceWin32 {
+    handle: vk::Device,
+    fp: vk::KhrExternalFenceWin32Fn,
+}
+
+impl ExternalFenceWin32 {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::KhrExternalFenceWin32Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportFenceWin32HandleKHR.html>
+    #[inline]
+    pub unsafe fn import_fence_win32_handle(
+        &self,
+        import_info: &vk::ImportFenceWin32HandleInfoKHR,
+    ) -> VkResult<()> {
+        (self.fp.import_fence_win32_handle_khr)(self.handle, import_info).result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetFenceWin32HandleKHR.html>
+    #[inline]
+    pub unsafe fn get_fence_win32_handle(
+        &self,
+        get_info: &vk::FenceGetWin32HandleInfoKHR,
+    ) -> VkResult<vk::HANDLE> {
+        let mut handle = ptr::null_mut();
+        (self.fp.get_fence_win32_handle_khr)(self.handle, get_info, &mut handle)
+            .result_with_success(handle)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrExternalFenceWin32Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrExternalFenceWin32Fn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/khr/external_memory_fd.rs b/src/extensions/khr/external_memory_fd.rs
index 7eeaa3e..77e66c2 100644
--- a/src/extensions/khr/external_memory_fd.rs
+++ b/src/extensions/khr/external_memory_fd.rs
@@ -7,49 +7,53 @@ use std::mem;
 #[derive(Clone)]
 pub struct ExternalMemoryFd {
     handle: vk::Device,
-    external_memory_fd_fn: vk::KhrExternalMemoryFdFn,
+    fp: vk::KhrExternalMemoryFdFn,
 }
 
 impl ExternalMemoryFd {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let external_memory_fd_fn = vk::KhrExternalMemoryFdFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrExternalMemoryFdFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            external_memory_fd_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrExternalMemoryFdFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryFdKHR.html>"]
-    pub unsafe fn get_memory_fd(&self, create_info: &vk::MemoryGetFdInfoKHR) -> VkResult<i32> {
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryFdKHR.html>
+    #[inline]
+    pub unsafe fn get_memory_fd(&self, get_fd_info: &vk::MemoryGetFdInfoKHR) -> VkResult<i32> {
         let mut fd = -1;
-
-        self.external_memory_fd_fn
-            .get_memory_fd_khr(self.handle, create_info, &mut fd)
-            .result_with_success(fd)
+        (self.fp.get_memory_fd_khr)(self.handle, get_fd_info, &mut fd).result_with_success(fd)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryFdPropertiesKHR.html>"]
-    pub unsafe fn get_memory_fd_properties_khr(
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryFdPropertiesKHR.html>
+    #[inline]
+    pub unsafe fn get_memory_fd_properties(
         &self,
         handle_type: vk::ExternalMemoryHandleTypeFlags,
         fd: i32,
     ) -> VkResult<vk::MemoryFdPropertiesKHR> {
         let mut memory_fd_properties = Default::default();
-        self.external_memory_fd_fn
-            .get_memory_fd_properties_khr(self.handle, handle_type, fd, &mut memory_fd_properties)
-            .result_with_success(memory_fd_properties)
+        (self.fp.get_memory_fd_properties_khr)(
+            self.handle,
+            handle_type,
+            fd,
+            &mut memory_fd_properties,
+        )
+        .result_with_success(memory_fd_properties)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrExternalMemoryFdFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrExternalMemoryFdFn {
-        &self.external_memory_fd_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/external_memory_win32.rs b/src/extensions/khr/external_memory_win32.rs
new file mode 100644
index 0000000..8e43a26
--- /dev/null
+++ b/src/extensions/khr/external_memory_win32.rs
@@ -0,0 +1,66 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+use std::ptr;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_memory_win32.html>
+#[derive(Clone)]
+pub struct ExternalMemoryWin32 {
+    handle: vk::Device,
+    fp: vk::KhrExternalMemoryWin32Fn,
+}
+
+impl ExternalMemoryWin32 {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::KhrExternalMemoryWin32Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryWin32HandleKHR.html>
+    #[inline]
+    pub unsafe fn get_memory_win32_handle(
+        &self,
+        create_info: &vk::MemoryGetWin32HandleInfoKHR,
+    ) -> VkResult<vk::HANDLE> {
+        let mut handle = ptr::null_mut();
+        (self.fp.get_memory_win32_handle_khr)(self.handle, create_info, &mut handle)
+            .result_with_success(handle)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetMemoryWin32HandlePropertiesKHR.html>
+    #[inline]
+    pub unsafe fn get_memory_win32_handle_properties(
+        &self,
+        handle_type: vk::ExternalMemoryHandleTypeFlags,
+        handle: vk::HANDLE,
+    ) -> VkResult<vk::MemoryWin32HandlePropertiesKHR> {
+        let mut memory_win32_handle_properties = Default::default();
+        (self.fp.get_memory_win32_handle_properties_khr)(
+            self.handle,
+            handle_type,
+            handle,
+            &mut memory_win32_handle_properties,
+        )
+        .result_with_success(memory_win32_handle_properties)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrExternalMemoryWin32Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrExternalMemoryWin32Fn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/khr/external_semaphore_fd.rs b/src/extensions/khr/external_semaphore_fd.rs
index 6d99201..eadebef 100644
--- a/src/extensions/khr/external_semaphore_fd.rs
+++ b/src/extensions/khr/external_semaphore_fd.rs
@@ -7,47 +7,45 @@ use std::mem;
 #[derive(Clone)]
 pub struct ExternalSemaphoreFd {
     handle: vk::Device,
-    external_semaphore_fd_fn: vk::KhrExternalSemaphoreFdFn,
+    fp: vk::KhrExternalSemaphoreFdFn,
 }
 
 impl ExternalSemaphoreFd {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let external_semaphore_fd_fn = vk::KhrExternalSemaphoreFdFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrExternalSemaphoreFdFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            external_semaphore_fd_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrExternalSemaphoreFdFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkImportSemaphoreFdKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportSemaphoreFdKHR.html>
+    #[inline]
     pub unsafe fn import_semaphore_fd(
         &self,
         import_info: &vk::ImportSemaphoreFdInfoKHR,
     ) -> VkResult<()> {
-        self.external_semaphore_fd_fn
-            .import_semaphore_fd_khr(self.handle, import_info)
-            .result()
+        (self.fp.import_semaphore_fd_khr)(self.handle, import_info).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreFdKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSemaphoreFdKHR.html>
+    #[inline]
     pub unsafe fn get_semaphore_fd(&self, get_info: &vk::SemaphoreGetFdInfoKHR) -> VkResult<i32> {
         let mut fd = -1;
+        (self.fp.get_semaphore_fd_khr)(self.handle, get_info, &mut fd).result_with_success(fd)
+    }
 
-        self.external_semaphore_fd_fn
-            .get_semaphore_fd_khr(self.handle, get_info, &mut fd)
-            .result_with_success(fd)
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrExternalSemaphoreFdFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrExternalSemaphoreFdFn {
-        &self.external_semaphore_fd_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/external_semaphore_win32.rs b/src/extensions/khr/external_semaphore_win32.rs
new file mode 100644
index 0000000..102da8c
--- /dev/null
+++ b/src/extensions/khr/external_semaphore_win32.rs
@@ -0,0 +1,58 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+use std::ptr;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_external_semaphore_win32.html>
+#[derive(Clone)]
+pub struct ExternalSemaphoreWin32 {
+    handle: vk::Device,
+    fp: vk::KhrExternalSemaphoreWin32Fn,
+}
+
+impl ExternalSemaphoreWin32 {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::KhrExternalSemaphoreWin32Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkImportSemaphoreWin32HandleKHR.html>
+    #[inline]
+    pub unsafe fn import_semaphore_win32_handle(
+        &self,
+        import_info: &vk::ImportSemaphoreWin32HandleInfoKHR,
+    ) -> VkResult<()> {
+        (self.fp.import_semaphore_win32_handle_khr)(self.handle, import_info).result()
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSemaphoreWin32HandleKHR.html>
+    #[inline]
+    pub unsafe fn get_semaphore_win32_handle(
+        &self,
+        get_info: &vk::SemaphoreGetWin32HandleInfoKHR,
+    ) -> VkResult<vk::HANDLE> {
+        let mut handle = ptr::null_mut();
+        (self.fp.get_semaphore_win32_handle_khr)(self.handle, get_info, &mut handle)
+            .result_with_success(handle)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrExternalSemaphoreWin32Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrExternalSemaphoreWin32Fn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/khr/get_memory_requirements2.rs b/src/extensions/khr/get_memory_requirements2.rs
index bdc7bfa..13e5a1b 100644
--- a/src/extensions/khr/get_memory_requirements2.rs
+++ b/src/extensions/khr/get_memory_requirements2.rs
@@ -7,79 +7,85 @@ use std::ptr;
 #[derive(Clone)]
 pub struct GetMemoryRequirements2 {
     handle: vk::Device,
-    get_memory_requirements2_fn: vk::KhrGetMemoryRequirements2Fn,
+    fp: vk::KhrGetMemoryRequirements2Fn,
 }
 
 impl GetMemoryRequirements2 {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let get_memory_requirements2_fn = vk::KhrGetMemoryRequirements2Fn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrGetMemoryRequirements2Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            get_memory_requirements2_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrGetMemoryRequirements2Fn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetBufferMemoryRequirements2KHR.html>
+    #[inline]
     pub unsafe fn get_buffer_memory_requirements2(
         &self,
         info: &vk::BufferMemoryRequirementsInfo2KHR,
         memory_requirements: &mut vk::MemoryRequirements2KHR,
     ) {
-        self.get_memory_requirements2_fn
-            .get_buffer_memory_requirements2_khr(self.handle, info, memory_requirements);
+        (self.fp.get_buffer_memory_requirements2_khr)(self.handle, info, memory_requirements);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageMemoryRequirements2KHR.html>
+    #[inline]
     pub unsafe fn get_image_memory_requirements2(
         &self,
         info: &vk::ImageMemoryRequirementsInfo2KHR,
         memory_requirements: &mut vk::MemoryRequirements2KHR,
     ) {
-        self.get_memory_requirements2_fn
-            .get_image_memory_requirements2_khr(self.handle, info, memory_requirements);
+        (self.fp.get_image_memory_requirements2_khr)(self.handle, info, memory_requirements);
     }
 
+    /// Retrieve the number of elements to pass to [`get_image_sparse_memory_requirements2()`][Self::get_image_sparse_memory_requirements2()]
+    #[inline]
     pub unsafe fn get_image_sparse_memory_requirements2_len(
         &self,
         info: &vk::ImageSparseMemoryRequirementsInfo2KHR,
     ) -> usize {
         let mut count = 0;
-        self.get_memory_requirements2_fn
-            .get_image_sparse_memory_requirements2_khr(
-                self.handle,
-                info,
-                &mut count,
-                ptr::null_mut(),
-            );
+        (self.fp.get_image_sparse_memory_requirements2_khr)(
+            self.handle,
+            info,
+            &mut count,
+            ptr::null_mut(),
+        );
         count as usize
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetImageSparseMemoryRequirements2KHR.html>
+    ///
+    /// Call [`get_image_sparse_memory_requirements2_len()`][Self::get_image_sparse_memory_requirements2_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
     pub unsafe fn get_image_sparse_memory_requirements2(
         &self,
         info: &vk::ImageSparseMemoryRequirementsInfo2KHR,
-        sparse_memory_requirements: &mut [vk::SparseImageMemoryRequirements2KHR],
+        out: &mut [vk::SparseImageMemoryRequirements2KHR],
     ) {
-        let mut count = sparse_memory_requirements.len() as u32;
-        self.get_memory_requirements2_fn
-            .get_image_sparse_memory_requirements2_khr(
-                self.handle,
-                info,
-                &mut count,
-                sparse_memory_requirements.as_mut_ptr(),
-            );
+        let mut count = out.len() as u32;
+        (self.fp.get_image_sparse_memory_requirements2_khr)(
+            self.handle,
+            info,
+            &mut count,
+            out.as_mut_ptr(),
+        );
+        assert_eq!(count as usize, out.len());
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrGetMemoryRequirements2Fn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrGetMemoryRequirements2Fn {
-        &self.get_memory_requirements2_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/get_physical_device_properties2.rs b/src/extensions/khr/get_physical_device_properties2.rs
index 57609fa..9e610b4 100644
--- a/src/extensions/khr/get_physical_device_properties2.rs
+++ b/src/extensions/khr/get_physical_device_properties2.rs
@@ -1,156 +1,167 @@
 use crate::prelude::*;
 use crate::vk;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 use std::ptr;
 
 #[derive(Clone)]
 pub struct GetPhysicalDeviceProperties2 {
-    handle: vk::Instance,
-    get_physical_device_properties2_fn: vk::KhrGetPhysicalDeviceProperties2Fn,
+    fp: vk::KhrGetPhysicalDeviceProperties2Fn,
 }
 
 impl GetPhysicalDeviceProperties2 {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let get_physical_device_properties2_fn =
-            vk::KhrGetPhysicalDeviceProperties2Fn::load(|name| unsafe {
-                mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
-            });
-        Self {
-            handle: instance.handle(),
-            get_physical_device_properties2_fn,
-        }
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let fp = vk::KhrGetPhysicalDeviceProperties2Fn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrGetPhysicalDeviceProperties2Fn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFeatures2KHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_features2(
         &self,
         physical_device: vk::PhysicalDevice,
         features: &mut vk::PhysicalDeviceFeatures2KHR,
     ) {
-        self.get_physical_device_properties2_fn
-            .get_physical_device_features2_khr(physical_device, features);
+        (self.fp.get_physical_device_features2_khr)(physical_device, features);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_format_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         format: vk::Format,
         format_properties: &mut vk::FormatProperties2KHR,
     ) {
-        self.get_physical_device_properties2_fn
-            .get_physical_device_format_properties2_khr(physical_device, format, format_properties);
+        (self.fp.get_physical_device_format_properties2_khr)(
+            physical_device,
+            format,
+            format_properties,
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_image_format_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         image_format_info: &vk::PhysicalDeviceImageFormatInfo2KHR,
         image_format_properties: &mut vk::ImageFormatProperties2KHR,
     ) -> VkResult<()> {
-        self.get_physical_device_properties2_fn
-            .get_physical_device_image_format_properties2_khr(
-                physical_device,
-                image_format_info,
-                image_format_properties,
-            )
-            .result()
+        (self.fp.get_physical_device_image_format_properties2_khr)(
+            physical_device,
+            image_format_info,
+            image_format_properties,
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_memory_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         memory_properties: &mut vk::PhysicalDeviceMemoryProperties2KHR,
     ) {
-        self.get_physical_device_properties2_fn
-            .get_physical_device_memory_properties2_khr(physical_device, memory_properties);
+        (self.fp.get_physical_device_memory_properties2_khr)(physical_device, memory_properties);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceProperties2KHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         properties: &mut vk::PhysicalDeviceProperties2KHR,
     ) {
-        self.get_physical_device_properties2_fn
-            .get_physical_device_properties2_khr(physical_device, properties);
+        (self.fp.get_physical_device_properties2_khr)(physical_device, properties);
     }
 
+    /// Retrieve the number of elements to pass to [`get_physical_device_queue_family_properties2()`][Self::get_physical_device_queue_family_properties2()]
+    #[inline]
     pub unsafe fn get_physical_device_queue_family_properties2_len(
         &self,
         physical_device: vk::PhysicalDevice,
     ) -> usize {
         let mut count = 0;
-        self.get_physical_device_properties2_fn
-            .get_physical_device_queue_family_properties2_khr(
-                physical_device,
-                &mut count,
-                ptr::null_mut(),
-            );
+        (self.fp.get_physical_device_queue_family_properties2_khr)(
+            physical_device,
+            &mut count,
+            ptr::null_mut(),
+        );
         count as usize
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html>
+    ///
+    /// Call [`get_physical_device_queue_family_properties2_len()`][Self::get_physical_device_queue_family_properties2_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
     pub unsafe fn get_physical_device_queue_family_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
-        queue_family_properties: &mut [vk::QueueFamilyProperties2KHR],
+        out: &mut [vk::QueueFamilyProperties2KHR],
     ) {
-        let mut count = queue_family_properties.len() as u32;
-        self.get_physical_device_properties2_fn
-            .get_physical_device_queue_family_properties2_khr(
-                physical_device,
-                &mut count,
-                queue_family_properties.as_mut_ptr(),
-            );
+        let mut count = out.len() as u32;
+        (self.fp.get_physical_device_queue_family_properties2_khr)(
+            physical_device,
+            &mut count,
+            out.as_mut_ptr(),
+        );
+        assert_eq!(count as usize, out.len());
     }
 
+    /// Retrieve the number of elements to pass to [`get_physical_device_sparse_image_format_properties2()`][Self::get_physical_device_sparse_image_format_properties2()]
+    #[inline]
     pub unsafe fn get_physical_device_sparse_image_format_properties2_len(
         &self,
         physical_device: vk::PhysicalDevice,
         format_info: &vk::PhysicalDeviceSparseImageFormatInfo2KHR,
     ) -> usize {
         let mut count = 0;
-        self.get_physical_device_properties2_fn
-            .get_physical_device_sparse_image_format_properties2_khr(
-                physical_device,
-                format_info,
-                &mut count,
-                ptr::null_mut(),
-            );
+        (self
+            .fp
+            .get_physical_device_sparse_image_format_properties2_khr)(
+            physical_device,
+            format_info,
+            &mut count,
+            ptr::null_mut(),
+        );
         count as usize
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html>
+    ///
+    /// Call [`get_physical_device_sparse_image_format_properties2_len()`][Self::get_physical_device_sparse_image_format_properties2_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
     pub unsafe fn get_physical_device_sparse_image_format_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         format_info: &vk::PhysicalDeviceSparseImageFormatInfo2KHR,
-        properties: &mut [vk::SparseImageFormatProperties2KHR],
+        out: &mut [vk::SparseImageFormatProperties2KHR],
     ) {
-        let mut count = properties.len() as u32;
-        self.get_physical_device_properties2_fn
-            .get_physical_device_sparse_image_format_properties2_khr(
-                physical_device,
-                format_info,
-                &mut count,
-                properties.as_mut_ptr(),
-            );
+        let mut count = out.len() as u32;
+        (self
+            .fp
+            .get_physical_device_sparse_image_format_properties2_khr)(
+            physical_device,
+            format_info,
+            &mut count,
+            out.as_mut_ptr(),
+        );
+        assert_eq!(count as usize, out.len());
     }
 
-    pub fn fp(&self) -> &vk::KhrGetPhysicalDeviceProperties2Fn {
-        &self.get_physical_device_properties2_fn
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrGetPhysicalDeviceProperties2Fn::name()
     }
 
-    pub fn instance(&self) -> vk::Instance {
-        self.handle
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrGetPhysicalDeviceProperties2Fn {
+        &self.fp
     }
 }
diff --git a/src/extensions/khr/get_surface_capabilities2.rs b/src/extensions/khr/get_surface_capabilities2.rs
new file mode 100644
index 0000000..0208b7b
--- /dev/null
+++ b/src/extensions/khr/get_surface_capabilities2.rs
@@ -0,0 +1,84 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+#[derive(Clone)]
+pub struct GetSurfaceCapabilities2 {
+    fp: vk::KhrGetSurfaceCapabilities2Fn,
+}
+
+impl GetSurfaceCapabilities2 {
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let fp = vk::KhrGetSurfaceCapabilities2Fn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_surface_capabilities2(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR,
+    ) -> VkResult<vk::SurfaceCapabilities2KHR> {
+        let mut surface_capabilities = Default::default();
+        (self.fp.get_physical_device_surface_capabilities2_khr)(
+            physical_device,
+            surface_info,
+            &mut surface_capabilities,
+        )
+        .result_with_success(surface_capabilities)
+    }
+
+    /// Retrieve the number of elements to pass to [`get_physical_device_surface_formats2()`][Self::get_physical_device_surface_formats2()]
+    #[inline]
+    pub unsafe fn get_physical_device_surface_formats2_len(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR,
+    ) -> VkResult<usize> {
+        let mut count = 0;
+        let err_code = (self.fp.get_physical_device_surface_formats2_khr)(
+            physical_device,
+            surface_info,
+            &mut count,
+            std::ptr::null_mut(),
+        );
+        err_code.result_with_success(count as usize)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html>
+    ///
+    /// Call [`get_physical_device_surface_formats2_len()`][Self::get_physical_device_surface_formats2_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn get_physical_device_surface_formats2(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface_info: &vk::PhysicalDeviceSurfaceInfo2KHR,
+        out: &mut [vk::SurfaceFormat2KHR],
+    ) -> VkResult<()> {
+        let mut count = out.len() as u32;
+        let err_code = (self.fp.get_physical_device_surface_formats2_khr)(
+            physical_device,
+            surface_info,
+            &mut count,
+            out.as_mut_ptr(),
+        );
+        assert_eq!(count as usize, out.len());
+        err_code.result()
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrGetSurfaceCapabilities2Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrGetSurfaceCapabilities2Fn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/khr/maintenance1.rs b/src/extensions/khr/maintenance1.rs
index cea9709..1226d31 100644
--- a/src/extensions/khr/maintenance1.rs
+++ b/src/extensions/khr/maintenance1.rs
@@ -6,38 +6,39 @@ use std::mem;
 #[derive(Clone)]
 pub struct Maintenance1 {
     handle: vk::Device,
-    fns: vk::KhrMaintenance1Fn,
+    fp: vk::KhrMaintenance1Fn,
 }
 
 impl Maintenance1 {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let fns = vk::KhrMaintenance1Fn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrMaintenance1Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            fns,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrMaintenance1Fn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkTrimCommandPoolKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkTrimCommandPoolKHR.html>
+    #[inline]
     pub unsafe fn trim_command_pool(
         &self,
         command_pool: vk::CommandPool,
         flags: vk::CommandPoolTrimFlagsKHR,
     ) {
-        self.fns
-            .trim_command_pool_khr(self.handle, command_pool, flags);
+        (self.fp.trim_command_pool_khr)(self.handle, command_pool, flags);
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrMaintenance1Fn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrMaintenance1Fn {
-        &self.fns
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/maintenance3.rs b/src/extensions/khr/maintenance3.rs
index 4d8d72d..3b22959 100644
--- a/src/extensions/khr/maintenance3.rs
+++ b/src/extensions/khr/maintenance3.rs
@@ -6,38 +6,39 @@ use std::mem;
 #[derive(Clone)]
 pub struct Maintenance3 {
     handle: vk::Device,
-    fns: vk::KhrMaintenance3Fn,
+    fp: vk::KhrMaintenance3Fn,
 }
 
 impl Maintenance3 {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let fns = vk::KhrMaintenance3Fn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrMaintenance3Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            fns,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrMaintenance3Fn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDescriptorSetLayoutSupportKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDescriptorSetLayoutSupportKHR.html>
+    #[inline]
     pub unsafe fn get_descriptor_set_layout_support(
         &self,
         create_info: &vk::DescriptorSetLayoutCreateInfo,
         out: &mut vk::DescriptorSetLayoutSupportKHR,
     ) {
-        self.fns
-            .get_descriptor_set_layout_support_khr(self.handle, create_info, out);
+        (self.fp.get_descriptor_set_layout_support_khr)(self.handle, create_info, out);
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrMaintenance3Fn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrMaintenance3Fn {
-        &self.fns
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/maintenance4.rs b/src/extensions/khr/maintenance4.rs
new file mode 100644
index 0000000..7ec1781
--- /dev/null
+++ b/src/extensions/khr/maintenance4.rs
@@ -0,0 +1,91 @@
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+#[derive(Clone)]
+pub struct Maintenance4 {
+    handle: vk::Device,
+    fp: vk::KhrMaintenance4Fn,
+}
+
+impl Maintenance4 {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::KhrMaintenance4Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html>
+    #[inline]
+    pub unsafe fn get_device_buffer_memory_requirements(
+        &self,
+        memory_requirements: &vk::DeviceBufferMemoryRequirementsKHR,
+        out: &mut vk::MemoryRequirements2,
+    ) {
+        (self.fp.get_device_buffer_memory_requirements_khr)(self.handle, memory_requirements, out)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceImageMemoryRequirementsKHR.html>
+    #[inline]
+    pub unsafe fn get_device_image_memory_requirements(
+        &self,
+        memory_requirements: &vk::DeviceImageMemoryRequirementsKHR,
+        out: &mut vk::MemoryRequirements2,
+    ) {
+        (self.fp.get_device_image_memory_requirements_khr)(self.handle, memory_requirements, out)
+    }
+
+    /// Retrieve the number of elements to pass to [`get_device_image_sparse_memory_requirements()`][Self::get_device_image_sparse_memory_requirements()]
+    #[inline]
+    pub unsafe fn get_device_image_sparse_memory_requirements_len(
+        &self,
+        memory_requirements: &vk::DeviceImageMemoryRequirementsKHR,
+    ) -> usize {
+        let mut count = 0;
+        (self.fp.get_device_image_sparse_memory_requirements_khr)(
+            self.handle,
+            memory_requirements,
+            &mut count,
+            std::ptr::null_mut(),
+        );
+        count as usize
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html>
+    ///
+    /// Call [`get_device_image_sparse_memory_requirements_len()`][Self::get_device_image_sparse_memory_requirements_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn get_device_image_sparse_memory_requirements(
+        &self,
+        memory_requirements: &vk::DeviceImageMemoryRequirementsKHR,
+        out: &mut [vk::SparseImageMemoryRequirements2],
+    ) {
+        let mut count = out.len() as u32;
+        (self.fp.get_device_image_sparse_memory_requirements_khr)(
+            self.handle,
+            memory_requirements,
+            &mut count,
+            out.as_mut_ptr(),
+        );
+        assert_eq!(count as usize, out.len());
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrMaintenance4Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrMaintenance4Fn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/khr/mod.rs b/src/extensions/khr/mod.rs
index ef881ec..ff84d0d 100644
--- a/src/extensions/khr/mod.rs
+++ b/src/extensions/khr/mod.rs
@@ -1,20 +1,32 @@
 pub use self::acceleration_structure::AccelerationStructure;
 pub use self::android_surface::AndroidSurface;
 pub use self::buffer_device_address::BufferDeviceAddress;
+pub use self::copy_commands2::CopyCommands2;
 pub use self::create_render_pass2::CreateRenderPass2;
 pub use self::deferred_host_operations::DeferredHostOperations;
+pub use self::device_group::DeviceGroup;
+pub use self::device_group_creation::DeviceGroupCreation;
 pub use self::display::Display;
 pub use self::display_swapchain::DisplaySwapchain;
 pub use self::draw_indirect_count::DrawIndirectCount;
+pub use self::dynamic_rendering::DynamicRendering;
 pub use self::external_fence_fd::ExternalFenceFd;
+pub use self::external_fence_win32::ExternalFenceWin32;
 pub use self::external_memory_fd::ExternalMemoryFd;
+pub use self::external_memory_win32::ExternalMemoryWin32;
 pub use self::external_semaphore_fd::ExternalSemaphoreFd;
+pub use self::external_semaphore_win32::ExternalSemaphoreWin32;
 pub use self::get_memory_requirements2::GetMemoryRequirements2;
 pub use self::get_physical_device_properties2::GetPhysicalDeviceProperties2;
+pub use self::get_surface_capabilities2::GetSurfaceCapabilities2;
 pub use self::maintenance1::Maintenance1;
 pub use self::maintenance3::Maintenance3;
+pub use self::maintenance4::Maintenance4;
+pub use self::performance_query::PerformanceQuery;
 pub use self::pipeline_executable_properties::PipelineExecutableProperties;
+pub use self::present_wait::PresentWait;
 pub use self::push_descriptor::PushDescriptor;
+pub use self::ray_tracing_maintenance1::RayTracingMaintenance1;
 pub use self::ray_tracing_pipeline::RayTracingPipeline;
 pub use self::surface::Surface;
 pub use self::swapchain::Swapchain;
@@ -28,20 +40,32 @@ pub use self::xlib_surface::XlibSurface;
 mod acceleration_structure;
 mod android_surface;
 mod buffer_device_address;
+mod copy_commands2;
 mod create_render_pass2;
 mod deferred_host_operations;
+mod device_group;
+mod device_group_creation;
 mod display;
 mod display_swapchain;
 mod draw_indirect_count;
+mod dynamic_rendering;
 mod external_fence_fd;
+mod external_fence_win32;
 mod external_memory_fd;
+mod external_memory_win32;
 mod external_semaphore_fd;
+mod external_semaphore_win32;
 mod get_memory_requirements2;
 mod get_physical_device_properties2;
+mod get_surface_capabilities2;
 mod maintenance1;
 mod maintenance3;
+mod maintenance4;
+mod performance_query;
 mod pipeline_executable_properties;
+mod present_wait;
 mod push_descriptor;
+mod ray_tracing_maintenance1;
 mod ray_tracing_pipeline;
 mod surface;
 mod swapchain;
diff --git a/src/extensions/khr/performance_query.rs b/src/extensions/khr/performance_query.rs
new file mode 100644
index 0000000..6910b5a
--- /dev/null
+++ b/src/extensions/khr/performance_query.rs
@@ -0,0 +1,121 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+use std::ptr;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_performance_query.html>
+#[derive(Clone)]
+pub struct PerformanceQuery {
+    handle: vk::Instance,
+    fp: vk::KhrPerformanceQueryFn,
+}
+
+impl PerformanceQuery {
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrPerformanceQueryFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// Retrieve the number of elements to pass to [`enumerate_physical_device_queue_family_performance_query_counters()`][Self::enumerate_physical_device_queue_family_performance_query_counters()]
+    #[inline]
+    pub unsafe fn enumerate_physical_device_queue_family_performance_query_counters_len(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        queue_family_index: u32,
+    ) -> VkResult<usize> {
+        let mut count = 0;
+        (self
+            .fp
+            .enumerate_physical_device_queue_family_performance_query_counters_khr)(
+            physical_device,
+            queue_family_index,
+            &mut count,
+            ptr::null_mut(),
+            ptr::null_mut(),
+        )
+        .result_with_success(count as usize)
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html>
+    ///
+    /// Call [`enumerate_physical_device_queue_family_performance_query_counters_len()`][Self::enumerate_physical_device_queue_family_performance_query_counters_len()] to query the number of elements to pass to `out_counters` and `out_counter_descriptions`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn enumerate_physical_device_queue_family_performance_query_counters(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        queue_family_index: u32,
+        out_counters: &mut [vk::PerformanceCounterKHR],
+        out_counter_descriptions: &mut [vk::PerformanceCounterDescriptionKHR],
+    ) -> VkResult<()> {
+        assert_eq!(out_counters.len(), out_counter_descriptions.len());
+        let mut count = out_counters.len() as u32;
+        (self
+            .fp
+            .enumerate_physical_device_queue_family_performance_query_counters_khr)(
+            physical_device,
+            queue_family_index,
+            &mut count,
+            out_counters.as_mut_ptr(),
+            out_counter_descriptions.as_mut_ptr(),
+        )
+        .result()?;
+        assert_eq!(count as usize, out_counters.len());
+        assert_eq!(count as usize, out_counter_descriptions.len());
+        Ok(())
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html>
+    #[inline]
+    pub unsafe fn get_physical_device_queue_family_performance_query_passes(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        performance_query_create_info: &vk::QueryPoolPerformanceCreateInfoKHR,
+    ) -> u32 {
+        let mut num_passes = 0;
+        (self
+            .fp
+            .get_physical_device_queue_family_performance_query_passes_khr)(
+            physical_device,
+            performance_query_create_info,
+            &mut num_passes,
+        );
+        num_passes
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkAcquireProfilingLockKHR.html>
+    #[inline]
+    pub unsafe fn acquire_profiling_lock(
+        &self,
+        device: vk::Device,
+        info: &vk::AcquireProfilingLockInfoKHR,
+    ) -> VkResult<()> {
+        (self.fp.acquire_profiling_lock_khr)(device, info).result()
+    }
+
+    /// <https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/vkReleaseProfilingLockKHR.html>
+    #[inline]
+    pub unsafe fn release_profiling_lock(&self, device: vk::Device) {
+        (self.fp.release_profiling_lock_khr)(device)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrPerformanceQueryFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrPerformanceQueryFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn instance(&self) -> vk::Instance {
+        self.handle
+    }
+}
diff --git a/src/extensions/khr/pipeline_executable_properties.rs b/src/extensions/khr/pipeline_executable_properties.rs
index fd85a76..68e43b4 100644
--- a/src/extensions/khr/pipeline_executable_properties.rs
+++ b/src/extensions/khr/pipeline_executable_properties.rs
@@ -1,77 +1,84 @@
 use crate::prelude::*;
 use crate::vk;
-use crate::{EntryCustom, Instance};
+use crate::{Device, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct PipelineExecutableProperties {
-    handle: vk::Instance,
-    pipeline_executable_properties_fn: vk::KhrPipelineExecutablePropertiesFn,
+    handle: vk::Device,
+    fp: vk::KhrPipelineExecutablePropertiesFn,
 }
 
 impl PipelineExecutableProperties {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let pipeline_executable_properties_fn =
-            vk::KhrPipelineExecutablePropertiesFn::load(|name| unsafe {
-                mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
-            });
-        Self {
-            handle: instance.handle(),
-            pipeline_executable_properties_fn,
-        }
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::KhrPipelineExecutablePropertiesFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrPipelineExecutablePropertiesFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html>
+    #[inline]
     pub unsafe fn get_pipeline_executable_internal_representations(
         &self,
-        device: vk::Device,
         executable_info: &vk::PipelineExecutableInfoKHR,
     ) -> VkResult<Vec<vk::PipelineExecutableInternalRepresentationKHR>> {
         read_into_defaulted_vector(|count, data| {
-            self.pipeline_executable_properties_fn
-                .get_pipeline_executable_internal_representations_khr(
-                    device,
-                    executable_info,
-                    count,
-                    data,
-                )
+            (self.fp.get_pipeline_executable_internal_representations_khr)(
+                self.handle,
+                executable_info,
+                count,
+                data,
+            )
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineExecutablePropertiesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPipelineExecutablePropertiesKHR.html>
+    #[inline]
     pub unsafe fn get_pipeline_executable_properties(
         &self,
-        device: vk::Device,
         pipeline_info: &vk::PipelineInfoKHR,
     ) -> VkResult<Vec<vk::PipelineExecutablePropertiesKHR>> {
         read_into_defaulted_vector(|count, data| {
-            self.pipeline_executable_properties_fn
-                .get_pipeline_executable_properties_khr(device, pipeline_info, count, data)
+            (self.fp.get_pipeline_executable_properties_khr)(
+                self.handle,
+                pipeline_info,
+                count,
+                data,
+            )
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineExecutableStatisticsKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPipelineExecutableStatisticsKHR.html>
+    #[inline]
     pub unsafe fn get_pipeline_executable_statistics(
         &self,
-        device: vk::Device,
         executable_info: &vk::PipelineExecutableInfoKHR,
     ) -> VkResult<Vec<vk::PipelineExecutableStatisticKHR>> {
         read_into_defaulted_vector(|count, data| {
-            self.pipeline_executable_properties_fn
-                .get_pipeline_executable_statistics_khr(device, executable_info, count, data)
+            (self.fp.get_pipeline_executable_statistics_khr)(
+                self.handle,
+                executable_info,
+                count,
+                data,
+            )
         })
     }
 
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrPipelineExecutablePropertiesFn::name()
+    }
+
+    #[inline]
     pub fn fp(&self) -> &vk::KhrPipelineExecutablePropertiesFn {
-        &self.pipeline_executable_properties_fn
+        &self.fp
     }
 
-    pub fn instance(&self) -> vk::Instance {
+    #[inline]
+    pub fn device(&self) -> vk::Device {
         self.handle
     }
 }
diff --git a/src/extensions/khr/present_wait.rs b/src/extensions/khr/present_wait.rs
new file mode 100644
index 0000000..4d8effe
--- /dev/null
+++ b/src/extensions/khr/present_wait.rs
@@ -0,0 +1,47 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+#[derive(Clone)]
+pub struct PresentWait {
+    handle: vk::Device,
+    fp: vk::KhrPresentWaitFn,
+}
+
+impl PresentWait {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::KhrPresentWaitFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { handle, fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkWaitForPresentKHR.html>
+    #[inline]
+    pub unsafe fn wait_for_present(
+        &self,
+        swapchain: vk::SwapchainKHR,
+        present_id: u64,
+        timeout: u64,
+    ) -> VkResult<()> {
+        (self.fp.wait_for_present_khr)(self.handle, swapchain, present_id, timeout).result()
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrPresentWaitFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrPresentWaitFn {
+        &self.fp
+    }
+
+    #[inline]
+    pub fn device(&self) -> vk::Device {
+        self.handle
+    }
+}
diff --git a/src/extensions/khr/push_descriptor.rs b/src/extensions/khr/push_descriptor.rs
index eb90c97..22d1572 100644
--- a/src/extensions/khr/push_descriptor.rs
+++ b/src/extensions/khr/push_descriptor.rs
@@ -6,26 +6,19 @@ use std::mem;
 
 #[derive(Clone)]
 pub struct PushDescriptor {
-    handle: vk::Instance,
-    push_descriptors_fn: vk::KhrPushDescriptorFn,
+    fp: vk::KhrPushDescriptorFn,
 }
 
 impl PushDescriptor {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let push_descriptors_fn = vk::KhrPushDescriptorFn::load(|name| unsafe {
+        let fp = vk::KhrPushDescriptorFn::load(|name| unsafe {
             mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            push_descriptors_fn,
-        }
+        Self { fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrPushDescriptorFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushDescriptorSetKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdPushDescriptorSetKHR.html>
+    #[inline]
     pub unsafe fn cmd_push_descriptor_set(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -34,7 +27,7 @@ impl PushDescriptor {
         set: u32,
         descriptor_writes: &[vk::WriteDescriptorSet],
     ) {
-        self.push_descriptors_fn.cmd_push_descriptor_set_khr(
+        (self.fp.cmd_push_descriptor_set_khr)(
             command_buffer,
             pipeline_bind_point,
             layout,
@@ -44,7 +37,8 @@ impl PushDescriptor {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html>
+    #[inline]
     pub unsafe fn cmd_push_descriptor_set_with_template(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -53,21 +47,22 @@ impl PushDescriptor {
         set: u32,
         p_data: *const c_void,
     ) {
-        self.push_descriptors_fn
-            .cmd_push_descriptor_set_with_template_khr(
-                command_buffer,
-                descriptor_update_template,
-                layout,
-                set,
-                p_data,
-            );
+        (self.fp.cmd_push_descriptor_set_with_template_khr)(
+            command_buffer,
+            descriptor_update_template,
+            layout,
+            set,
+            p_data,
+        );
     }
 
-    pub fn fp(&self) -> &vk::KhrPushDescriptorFn {
-        &self.push_descriptors_fn
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrPushDescriptorFn::name()
     }
 
-    pub fn instance(&self) -> vk::Instance {
-        self.handle
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrPushDescriptorFn {
+        &self.fp
     }
 }
diff --git a/src/extensions/khr/ray_tracing_maintenance1.rs b/src/extensions/khr/ray_tracing_maintenance1.rs
new file mode 100644
index 0000000..a5159ad
--- /dev/null
+++ b/src/extensions/khr/ray_tracing_maintenance1.rs
@@ -0,0 +1,42 @@
+use crate::vk;
+use crate::{Device, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_ray_tracing_maintenance1.html>
+#[derive(Clone)]
+pub struct RayTracingMaintenance1 {
+    fp: vk::KhrRayTracingMaintenance1Fn,
+}
+
+impl RayTracingMaintenance1 {
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::KhrRayTracingMaintenance1Fn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysIndirect2KHR.html>
+    ///
+    /// `indirect_device_address` is a buffer device address which is a pointer to a [`vk::TraceRaysIndirectCommand2KHR`] structure containing the trace ray parameters.
+    #[inline]
+    pub unsafe fn cmd_trace_rays_indirect2(
+        &self,
+        command_buffer: vk::CommandBuffer,
+        indirect_device_address: vk::DeviceAddress,
+    ) {
+        (self.fp.cmd_trace_rays_indirect2_khr)(command_buffer, indirect_device_address);
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrRayTracingMaintenance1Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrRayTracingMaintenance1Fn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/khr/ray_tracing_pipeline.rs b/src/extensions/khr/ray_tracing_pipeline.rs
index 97edad7..af73343 100644
--- a/src/extensions/khr/ray_tracing_pipeline.rs
+++ b/src/extensions/khr/ray_tracing_pipeline.rs
@@ -8,20 +8,19 @@ use std::mem;
 #[derive(Clone)]
 pub struct RayTracingPipeline {
     handle: vk::Device,
-    ray_tracing_fn: vk::KhrRayTracingPipelineFn,
+    fp: vk::KhrRayTracingPipelineFn,
 }
 
 impl RayTracingPipeline {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let ray_tracing_fn = vk::KhrRayTracingPipelineFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrRayTracingPipelineFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            ray_tracing_fn,
-        }
+        Self { handle, fp }
     }
 
+    #[inline]
     pub unsafe fn get_properties(
         instance: &Instance,
         pdevice: vk::PhysicalDevice,
@@ -34,7 +33,8 @@ impl RayTracingPipeline {
         props_rt
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdTraceRaysKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysKHR.html>
+    #[inline]
     pub unsafe fn cmd_trace_rays(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -46,19 +46,20 @@ impl RayTracingPipeline {
         height: u32,
         depth: u32,
     ) {
-        self.ray_tracing_fn.cmd_trace_rays_khr(
+        (self.fp.cmd_trace_rays_khr)(
             command_buffer,
-            raygen_shader_binding_tables as *const _,
-            miss_shader_binding_tables as *const _,
-            hit_shader_binding_tables as *const _,
-            callable_shader_binding_tables as *const _,
+            raygen_shader_binding_tables,
+            miss_shader_binding_tables,
+            hit_shader_binding_tables,
+            callable_shader_binding_tables,
             width,
             height,
             depth,
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRayTracingPipelinesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateRayTracingPipelinesKHR.html>
+    #[inline]
     pub unsafe fn create_ray_tracing_pipelines(
         &self,
         deferred_operation: vk::DeferredOperationKHR,
@@ -67,20 +68,20 @@ impl RayTracingPipeline {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<Vec<vk::Pipeline>> {
         let mut pipelines = vec![mem::zeroed(); create_info.len()];
-        self.ray_tracing_fn
-            .create_ray_tracing_pipelines_khr(
-                self.handle,
-                deferred_operation,
-                pipeline_cache,
-                create_info.len() as u32,
-                create_info.as_ptr(),
-                allocation_callbacks.as_raw_ptr(),
-                pipelines.as_mut_ptr(),
-            )
-            .result_with_success(pipelines)
+        (self.fp.create_ray_tracing_pipelines_khr)(
+            self.handle,
+            deferred_operation,
+            pipeline_cache,
+            create_info.len() as u32,
+            create_info.as_ptr(),
+            allocation_callbacks.as_raw_ptr(),
+            pipelines.as_mut_ptr(),
+        )
+        .result_with_success(pipelines)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRayTracingShaderGroupHandlesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingShaderGroupHandlesKHR.html>
+    #[inline]
     pub unsafe fn get_ray_tracing_shader_group_handles(
         &self,
         pipeline: vk::Pipeline,
@@ -89,21 +90,21 @@ impl RayTracingPipeline {
         data_size: usize,
     ) -> VkResult<Vec<u8>> {
         let mut data = Vec::<u8>::with_capacity(data_size);
-        let err_code = self
-            .ray_tracing_fn
-            .get_ray_tracing_shader_group_handles_khr(
-                self.handle,
-                pipeline,
-                first_group,
-                group_count,
-                data_size,
-                data.as_mut_ptr() as *mut std::ffi::c_void,
-            );
+        (self.fp.get_ray_tracing_shader_group_handles_khr)(
+            self.handle,
+            pipeline,
+            first_group,
+            group_count,
+            data_size,
+            data.as_mut_ptr().cast(),
+        )
+        .result()?;
         data.set_len(data_size);
-        err_code.result_with_success(data)
+        Ok(data)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html>
+    #[inline]
     pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles(
         &self,
         pipeline: vk::Pipeline,
@@ -111,21 +112,26 @@ impl RayTracingPipeline {
         group_count: u32,
         data_size: usize,
     ) -> VkResult<Vec<u8>> {
-        let mut data: Vec<u8> = Vec::with_capacity(data_size);
-
-        self.ray_tracing_fn
-            .get_ray_tracing_capture_replay_shader_group_handles_khr(
-                self.handle,
-                pipeline,
-                first_group,
-                group_count,
-                data_size,
-                data.as_mut_ptr() as *mut _,
-            )
-            .result_with_success(data)
+        let mut data = Vec::<u8>::with_capacity(data_size);
+        (self
+            .fp
+            .get_ray_tracing_capture_replay_shader_group_handles_khr)(
+            self.handle,
+            pipeline,
+            first_group,
+            group_count,
+            data_size,
+            data.as_mut_ptr().cast(),
+        )
+        .result()?;
+        data.set_len(data_size);
+        Ok(data)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdTraceRaysIndirectKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysIndirectKHR.html>
+    ///
+    /// `indirect_device_address` is a buffer device address which is a pointer to a [`vk::TraceRaysIndirectCommandKHR`] structure containing the trace ray parameters.
+    #[inline]
     pub unsafe fn cmd_trace_rays_indirect(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -135,7 +141,7 @@ impl RayTracingPipeline {
         callable_shader_binding_table: &[vk::StridedDeviceAddressRegionKHR],
         indirect_device_address: vk::DeviceAddress,
     ) {
-        self.ray_tracing_fn.cmd_trace_rays_indirect_khr(
+        (self.fp.cmd_trace_rays_indirect_khr)(
             command_buffer,
             raygen_shader_binding_table.as_ptr(),
             miss_shader_binding_table.as_ptr(),
@@ -145,35 +151,43 @@ impl RayTracingPipeline {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html>
+    #[inline]
     pub unsafe fn get_ray_tracing_shader_group_stack_size(
         &self,
         pipeline: vk::Pipeline,
         group: u32,
         group_shader: vk::ShaderGroupShaderKHR,
     ) -> vk::DeviceSize {
-        self.ray_tracing_fn
-            .get_ray_tracing_shader_group_stack_size_khr(self.handle, pipeline, group, group_shader)
+        (self.fp.get_ray_tracing_shader_group_stack_size_khr)(
+            self.handle,
+            pipeline,
+            group,
+            group_shader,
+        )
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html>
+    #[inline]
     pub unsafe fn cmd_set_ray_tracing_pipeline_stack_size(
         &self,
         command_buffer: vk::CommandBuffer,
         pipeline_stack_size: u32,
     ) {
-        self.ray_tracing_fn
-            .cmd_set_ray_tracing_pipeline_stack_size_khr(command_buffer, pipeline_stack_size);
+        (self.fp.cmd_set_ray_tracing_pipeline_stack_size_khr)(command_buffer, pipeline_stack_size);
     }
 
-    pub fn name() -> &'static CStr {
+    #[inline]
+    pub const fn name() -> &'static CStr {
         vk::KhrRayTracingPipelineFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrRayTracingPipelineFn {
-        &self.ray_tracing_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/surface.rs b/src/extensions/khr/surface.rs
index 3c19d22..11508bd 100755
--- a/src/extensions/khr/surface.rs
+++ b/src/extensions/khr/surface.rs
@@ -1,32 +1,27 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct Surface {
     handle: vk::Instance,
-    surface_fn: vk::KhrSurfaceFn,
+    fp: vk::KhrSurfaceFn,
 }
 
 impl Surface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::KhrSurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrSurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_surface_support(
         &self,
         physical_device: vk::PhysicalDevice,
@@ -34,82 +29,81 @@ impl Surface {
         surface: vk::SurfaceKHR,
     ) -> VkResult<bool> {
         let mut b = 0;
-        self.surface_fn
-            .get_physical_device_surface_support_khr(
-                physical_device,
-                queue_family_index,
-                surface,
-                &mut b,
-            )
-            .result_with_success(b > 0)
+        (self.fp.get_physical_device_surface_support_khr)(
+            physical_device,
+            queue_family_index,
+            surface,
+            &mut b,
+        )
+        .result_with_success(b > 0)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_surface_present_modes(
         &self,
         physical_device: vk::PhysicalDevice,
         surface: vk::SurfaceKHR,
     ) -> VkResult<Vec<vk::PresentModeKHR>> {
         read_into_uninitialized_vector(|count, data| {
-            self.surface_fn
-                .get_physical_device_surface_present_modes_khr(
-                    physical_device,
-                    surface,
-                    count,
-                    data,
-                )
+            (self.fp.get_physical_device_surface_present_modes_khr)(
+                physical_device,
+                surface,
+                count,
+                data,
+            )
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_surface_capabilities(
         &self,
         physical_device: vk::PhysicalDevice,
         surface: vk::SurfaceKHR,
     ) -> VkResult<vk::SurfaceCapabilitiesKHR> {
         let mut surface_capabilities = mem::zeroed();
-        self.surface_fn
-            .get_physical_device_surface_capabilities_khr(
-                physical_device,
-                surface,
-                &mut surface_capabilities,
-            )
-            .result_with_success(surface_capabilities)
+        (self.fp.get_physical_device_surface_capabilities_khr)(
+            physical_device,
+            surface,
+            &mut surface_capabilities,
+        )
+        .result_with_success(surface_capabilities)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_surface_formats(
         &self,
         physical_device: vk::PhysicalDevice,
         surface: vk::SurfaceKHR,
     ) -> VkResult<Vec<vk::SurfaceFormatKHR>> {
         read_into_uninitialized_vector(|count, data| {
-            self.surface_fn.get_physical_device_surface_formats_khr(
-                physical_device,
-                surface,
-                count,
-                data,
-            )
+            (self.fp.get_physical_device_surface_formats_khr)(physical_device, surface, count, data)
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySurfaceKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroySurfaceKHR.html>
+    #[inline]
     pub unsafe fn destroy_surface(
         &self,
         surface: vk::SurfaceKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.surface_fn.destroy_surface_khr(
-            self.handle,
-            surface,
-            allocation_callbacks.as_raw_ptr(),
-        );
+        (self.fp.destroy_surface_khr)(self.handle, surface, allocation_callbacks.as_raw_ptr());
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrSurfaceFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrSurfaceFn {
-        &self.surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/khr/swapchain.rs b/src/extensions/khr/swapchain.rs
index 9fa86a6..ee608ef 100755
--- a/src/extensions/khr/swapchain.rs
+++ b/src/extensions/khr/swapchain.rs
@@ -1,46 +1,90 @@
+#[cfg(doc)]
+use super::DeviceGroup;
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{Device, Instance};
+use crate::{Device, Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html>
 #[derive(Clone)]
 pub struct Swapchain {
     handle: vk::Device,
-    swapchain_fn: vk::KhrSwapchainFn,
+    fp: vk::KhrSwapchainFn,
 }
 
 impl Swapchain {
+    /// # Warning
+    /// [`Instance`] functions cannot be loaded from a [`Device`] and will always panic when called:
+    /// - [`Self::get_physical_device_present_rectangles()`]
+    ///
+    /// Load this struct using an [`Instance`] instead via [`Self::new_from_instance()`] if the
+    /// above [`Instance`] function is called. This will be solved in the next breaking `ash`
+    /// release: <https://github.com/ash-rs/ash/issues/727>.
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let swapchain_fn = vk::KhrSwapchainFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::KhrSwapchainFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            swapchain_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrSwapchainFn::name()
+    /// Loads all functions on the [`Instance`] instead of [`Device`]. This incurs an extra
+    /// dispatch table for [`Device`] functions but also allows the [`Instance`] function to be
+    /// loaded instead of always panicking. See also [`Self::new()`] for more details.
+    ///
+    /// It is okay to pass [`vk::Device::null()`] when this struct is only used to call the
+    /// [`Instance`] function.
+    pub fn new_from_instance(entry: &Entry, instance: &Instance, device: vk::Device) -> Self {
+        let fp = vk::KhrSwapchainFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { handle: device, fp }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySwapchainKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateSwapchainKHR.html>
+    #[inline]
+    pub unsafe fn create_swapchain(
+        &self,
+        create_info: &vk::SwapchainCreateInfoKHR,
+        allocation_callbacks: Option<&vk::AllocationCallbacks>,
+    ) -> VkResult<vk::SwapchainKHR> {
+        let mut swapchain = mem::zeroed();
+        (self.fp.create_swapchain_khr)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut swapchain,
+        )
+        .result_with_success(swapchain)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroySwapchainKHR.html>
+    #[inline]
     pub unsafe fn destroy_swapchain(
         &self,
         swapchain: vk::SwapchainKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.swapchain_fn.destroy_swapchain_khr(
-            self.handle,
-            swapchain,
-            allocation_callbacks.as_raw_ptr(),
-        );
+        (self.fp.destroy_swapchain_khr)(self.handle, swapchain, allocation_callbacks.as_raw_ptr());
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSwapchainImagesKHR.html>
+    #[inline]
+    pub unsafe fn get_swapchain_images(
+        &self,
+        swapchain: vk::SwapchainKHR,
+    ) -> VkResult<Vec<vk::Image>> {
+        read_into_uninitialized_vector(|count, data| {
+            (self.fp.get_swapchain_images_khr)(self.handle, swapchain, count, data)
+        })
     }
 
     /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface.
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireNextImageKHR.html>"]
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireNextImageKHR.html>
+    #[inline]
     pub unsafe fn acquire_next_image(
         &self,
         swapchain: vk::SwapchainKHR,
@@ -49,7 +93,7 @@ impl Swapchain {
         fence: vk::Fence,
     ) -> VkResult<(u32, bool)> {
         let mut index = 0;
-        let err_code = self.swapchain_fn.acquire_next_image_khr(
+        let err_code = (self.fp.acquire_next_image_khr)(
             self.handle,
             swapchain,
             timeout,
@@ -64,31 +108,16 @@ impl Swapchain {
         }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSwapchainKHR.html>"]
-    pub unsafe fn create_swapchain(
-        &self,
-        create_info: &vk::SwapchainCreateInfoKHR,
-        allocation_callbacks: Option<&vk::AllocationCallbacks>,
-    ) -> VkResult<vk::SwapchainKHR> {
-        let mut swapchain = mem::zeroed();
-        self.swapchain_fn
-            .create_swapchain_khr(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut swapchain,
-            )
-            .result_with_success(swapchain)
-    }
-
     /// On success, returns whether the swapchain is suboptimal for the surface.
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueuePresentKHR.html>"]
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueuePresentKHR.html>
+    #[inline]
     pub unsafe fn queue_present(
         &self,
         queue: vk::Queue,
-        create_info: &vk::PresentInfoKHR,
+        present_info: &vk::PresentInfoKHR,
     ) -> VkResult<bool> {
-        let err_code = self.swapchain_fn.queue_present_khr(queue, create_info);
+        let err_code = (self.fp.queue_present_khr)(queue, present_info);
         match err_code {
             vk::Result::SUCCESS => Ok(false),
             vk::Result::SUBOPTIMAL_KHR => Ok(true),
@@ -96,21 +125,111 @@ impl Swapchain {
         }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSwapchainImagesKHR.html>"]
-    pub unsafe fn get_swapchain_images(
+    /// Only available since [Vulkan 1.1].
+    ///
+    /// Also available as [`DeviceGroup::get_device_group_present_capabilities()`]
+    /// when [`VK_KHR_surface`] is enabled.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html>
+    ///
+    /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html
+    /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html
+    #[inline]
+    pub unsafe fn get_device_group_present_capabilities(
         &self,
-        swapchain: vk::SwapchainKHR,
-    ) -> VkResult<Vec<vk::Image>> {
+        device_group_present_capabilities: &mut vk::DeviceGroupPresentCapabilitiesKHR,
+    ) -> VkResult<()> {
+        (self.fp.get_device_group_present_capabilities_khr)(
+            self.handle,
+            device_group_present_capabilities,
+        )
+        .result()
+    }
+
+    /// Only available since [Vulkan 1.1].
+    ///
+    /// Also available as [`DeviceGroup::get_device_group_surface_present_modes()`]
+    /// when [`VK_KHR_surface`] is enabled.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html>
+    ///
+    /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html
+    /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html
+    #[inline]
+    pub unsafe fn get_device_group_surface_present_modes(
+        &self,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<vk::DeviceGroupPresentModeFlagsKHR> {
+        let mut modes = mem::zeroed();
+        (self.fp.get_device_group_surface_present_modes_khr)(self.handle, surface, &mut modes)
+            .result_with_success(modes)
+    }
+
+    /// Only available since [Vulkan 1.1].
+    ///
+    /// Also available as [`DeviceGroup::get_physical_device_present_rectangles()`]
+    /// when [`VK_KHR_surface`] is enabled.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html>
+    ///
+    /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html
+    /// [`VK_KHR_surface`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_surface.html
+    ///
+    /// # Warning
+    ///
+    /// Function will always panic unless this struct is loaded via [`Self::new_from_instance()`].
+    #[inline]
+    pub unsafe fn get_physical_device_present_rectangles(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        surface: vk::SurfaceKHR,
+    ) -> VkResult<Vec<vk::Rect2D>> {
         read_into_uninitialized_vector(|count, data| {
-            self.swapchain_fn
-                .get_swapchain_images_khr(self.handle, swapchain, count, data)
+            (self.fp.get_physical_device_present_rectangles_khr)(
+                physical_device,
+                surface,
+                count,
+                data,
+            )
         })
     }
 
+    /// On success, returns the next image's index and whether the swapchain is suboptimal for the surface.
+    ///
+    /// Only available since [Vulkan 1.1].
+    ///
+    /// Also available as [`DeviceGroup::acquire_next_image2()`]
+    /// when [`VK_KHR_swapchain`] is enabled.
+    ///
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkAcquireNextImage2KHR.html>
+    ///
+    /// [Vulkan 1.1]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_1_1.html
+    /// [`VK_KHR_swapchain`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_KHR_swapchain.html
+    #[inline]
+    pub unsafe fn acquire_next_image2(
+        &self,
+        acquire_info: &vk::AcquireNextImageInfoKHR,
+    ) -> VkResult<(u32, bool)> {
+        let mut index = 0;
+        let err_code = (self.fp.acquire_next_image2_khr)(self.handle, acquire_info, &mut index);
+        match err_code {
+            vk::Result::SUCCESS => Ok((index, false)),
+            vk::Result::SUBOPTIMAL_KHR => Ok((index, true)),
+            _ => Err(err_code),
+        }
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrSwapchainFn::name()
+    }
+
+    #[inline]
     pub fn fp(&self) -> &vk::KhrSwapchainFn {
-        &self.swapchain_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/extensions/khr/synchronization2.rs b/src/extensions/khr/synchronization2.rs
index 4f0d4cd..d8baefd 100644
--- a/src/extensions/khr/synchronization2.rs
+++ b/src/extensions/khr/synchronization2.rs
@@ -6,66 +6,51 @@ use std::mem;
 
 #[derive(Clone)]
 pub struct Synchronization2 {
-    handle: vk::Device,
-    synchronization2_fn: vk::KhrSynchronization2Fn,
+    fp: vk::KhrSynchronization2Fn,
 }
 
 impl Synchronization2 {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let synchronization2_fn = vk::KhrSynchronization2Fn::load(|name| unsafe {
+        let fp = vk::KhrSynchronization2Fn::load(|name| unsafe {
             mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            synchronization2_fn,
-        }
+        Self { fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrSynchronization2Fn::name()
-    }
-
-    pub fn fp(&self) -> &vk::KhrSynchronization2Fn {
-        &self.synchronization2_fn
-    }
-
-    pub fn device(&self) -> vk::Device {
-        self.handle
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPipelineBarrier2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdPipelineBarrier2KHR.html>
+    #[inline]
     pub unsafe fn cmd_pipeline_barrier2(
         &self,
         command_buffer: vk::CommandBuffer,
         dependency_info: &vk::DependencyInfoKHR,
     ) {
-        self.synchronization2_fn
-            .cmd_pipeline_barrier2_khr(command_buffer, dependency_info)
+        (self.fp.cmd_pipeline_barrier2_khr)(command_buffer, dependency_info)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetEvent2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdResetEvent2KHR.html>
+    #[inline]
     pub unsafe fn cmd_reset_event2(
         &self,
         command_buffer: vk::CommandBuffer,
         event: vk::Event,
         stage_mask: vk::PipelineStageFlags2KHR,
     ) {
-        self.synchronization2_fn
-            .cmd_reset_event2_khr(command_buffer, event, stage_mask)
+        (self.fp.cmd_reset_event2_khr)(command_buffer, event, stage_mask)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetEvent2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetEvent2KHR.html>
+    #[inline]
     pub unsafe fn cmd_set_event2(
         &self,
         command_buffer: vk::CommandBuffer,
         event: vk::Event,
         dependency_info: &vk::DependencyInfoKHR,
     ) {
-        self.synchronization2_fn
-            .cmd_set_event2_khr(command_buffer, event, dependency_info)
+        (self.fp.cmd_set_event2_khr)(command_buffer, event, dependency_info)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWaitEvents2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWaitEvents2KHR.html>
+    #[inline]
     pub unsafe fn cmd_wait_events2(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -73,7 +58,7 @@ impl Synchronization2 {
         dependency_infos: &[vk::DependencyInfoKHR],
     ) {
         assert_eq!(events.len(), dependency_infos.len());
-        self.synchronization2_fn.cmd_wait_events2_khr(
+        (self.fp.cmd_wait_events2_khr)(
             command_buffer,
             events.len() as u32,
             events.as_ptr(),
@@ -81,7 +66,8 @@ impl Synchronization2 {
         )
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWriteTimestamp2KHR.html>
+    #[inline]
     pub unsafe fn cmd_write_timestamp2(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -89,19 +75,27 @@ impl Synchronization2 {
         query_pool: vk::QueryPool,
         query: u32,
     ) {
-        self.synchronization2_fn
-            .cmd_write_timestamp2_khr(command_buffer, stage, query_pool, query)
+        (self.fp.cmd_write_timestamp2_khr)(command_buffer, stage, query_pool, query)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueSubmit2KHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkQueueSubmit2KHR.html>
+    #[inline]
     pub unsafe fn queue_submit2(
         &self,
         queue: vk::Queue,
         submits: &[vk::SubmitInfo2KHR],
         fence: vk::Fence,
     ) -> VkResult<()> {
-        self.synchronization2_fn
-            .queue_submit2_khr(queue, submits.len() as u32, submits.as_ptr(), fence)
-            .result()
+        (self.fp.queue_submit2_khr)(queue, submits.len() as u32, submits.as_ptr(), fence).result()
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrSynchronization2Fn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::KhrSynchronization2Fn {
+        &self.fp
     }
 }
diff --git a/src/extensions/khr/timeline_semaphore.rs b/src/extensions/khr/timeline_semaphore.rs
index fca074e..de9a492 100644
--- a/src/extensions/khr/timeline_semaphore.rs
+++ b/src/extensions/khr/timeline_semaphore.rs
@@ -1,70 +1,60 @@
 use crate::prelude::*;
 use crate::vk;
-use crate::{EntryCustom, Instance};
+use crate::{Device, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct TimelineSemaphore {
-    handle: vk::Instance,
-    timeline_semaphore_fn: vk::KhrTimelineSemaphoreFn,
+    handle: vk::Device,
+    fp: vk::KhrTimelineSemaphoreFn,
 }
 
 impl TimelineSemaphore {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let timeline_semaphore_fn = vk::KhrTimelineSemaphoreFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(instance: &Instance, device: &Device) -> Self {
+        let handle = device.handle();
+        let fp = vk::KhrTimelineSemaphoreFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            timeline_semaphore_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrTimelineSemaphoreFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreCounterValue.html>"]
-    pub unsafe fn get_semaphore_counter_value(
-        &self,
-        device: vk::Device,
-        semaphore: vk::Semaphore,
-    ) -> VkResult<u64> {
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetSemaphoreCounterValue.html>
+    #[inline]
+    pub unsafe fn get_semaphore_counter_value(&self, semaphore: vk::Semaphore) -> VkResult<u64> {
         let mut value = 0;
-        self.timeline_semaphore_fn
-            .get_semaphore_counter_value_khr(device, semaphore, &mut value)
+        (self.fp.get_semaphore_counter_value_khr)(self.handle, semaphore, &mut value)
             .result_with_success(value)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitSemaphores.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkWaitSemaphores.html>
+    #[inline]
     pub unsafe fn wait_semaphores(
         &self,
-        device: vk::Device,
         wait_info: &vk::SemaphoreWaitInfo,
         timeout: u64,
     ) -> VkResult<()> {
-        self.timeline_semaphore_fn
-            .wait_semaphores_khr(device, wait_info, timeout)
-            .into()
+        (self.fp.wait_semaphores_khr)(self.handle, wait_info, timeout).result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSignalSemaphore.html>"]
-    pub unsafe fn signal_semaphore(
-        &self,
-        device: vk::Device,
-        signal_info: &vk::SemaphoreSignalInfo,
-    ) -> VkResult<()> {
-        self.timeline_semaphore_fn
-            .signal_semaphore_khr(device, signal_info)
-            .into()
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkSignalSemaphore.html>
+    #[inline]
+    pub unsafe fn signal_semaphore(&self, signal_info: &vk::SemaphoreSignalInfo) -> VkResult<()> {
+        (self.fp.signal_semaphore_khr)(self.handle, signal_info).result()
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrTimelineSemaphoreFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::KhrTimelineSemaphoreFn {
-        &self.timeline_semaphore_fn
+        &self.fp
     }
 
-    pub fn instance(&self) -> vk::Instance {
+    #[inline]
+    pub fn device(&self) -> vk::Device {
         self.handle
     }
 }
diff --git a/src/extensions/khr/wayland_surface.rs b/src/extensions/khr/wayland_surface.rs
index d4983df..d51fcb9 100755
--- a/src/extensions/khr/wayland_surface.rs
+++ b/src/extensions/khr/wayland_surface.rs
@@ -1,70 +1,70 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct WaylandSurface {
     handle: vk::Instance,
-    wayland_surface_fn: vk::KhrWaylandSurfaceFn,
+    fp: vk::KhrWaylandSurfaceFn,
 }
 
 impl WaylandSurface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::KhrWaylandSurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrWaylandSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            wayland_surface_fn: surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrWaylandSurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateWaylandSurfaceKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateWaylandSurfaceKHR.html>
+    #[inline]
     pub unsafe fn create_wayland_surface(
         &self,
         create_info: &vk::WaylandSurfaceCreateInfoKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        self.wayland_surface_fn
-            .create_wayland_surface_khr(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut surface,
-            )
-            .result_with_success(surface)
+        (self.fp.create_wayland_surface_khr)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_wayland_presentation_support(
         &self,
         physical_device: vk::PhysicalDevice,
         queue_family_index: u32,
         wl_display: &mut vk::wl_display,
     ) -> bool {
-        let b = self
-            .wayland_surface_fn
-            .get_physical_device_wayland_presentation_support_khr(
-                physical_device,
-                queue_family_index,
-                wl_display,
-            );
+        let b = (self.fp.get_physical_device_wayland_presentation_support_khr)(
+            physical_device,
+            queue_family_index,
+            wl_display,
+        );
 
         b > 0
     }
 
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrWaylandSurfaceFn::name()
+    }
+
+    #[inline]
     pub fn fp(&self) -> &vk::KhrWaylandSurfaceFn {
-        &self.wayland_surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/khr/win32_surface.rs b/src/extensions/khr/win32_surface.rs
index d037fba..be56a02 100755
--- a/src/extensions/khr/win32_surface.rs
+++ b/src/extensions/khr/win32_surface.rs
@@ -1,68 +1,68 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct Win32Surface {
     handle: vk::Instance,
-    win32_surface_fn: vk::KhrWin32SurfaceFn,
+    fp: vk::KhrWin32SurfaceFn,
 }
 
 impl Win32Surface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::KhrWin32SurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrWin32SurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            win32_surface_fn: surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrWin32SurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateWin32SurfaceKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateWin32SurfaceKHR.html>
+    #[inline]
     pub unsafe fn create_win32_surface(
         &self,
         create_info: &vk::Win32SurfaceCreateInfoKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        self.win32_surface_fn
-            .create_win32_surface_khr(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut surface,
-            )
-            .result_with_success(surface)
+        (self.fp.create_win32_surface_khr)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_win32_presentation_support(
         &self,
         physical_device: vk::PhysicalDevice,
         queue_family_index: u32,
     ) -> bool {
-        let b = self
-            .win32_surface_fn
-            .get_physical_device_win32_presentation_support_khr(
-                physical_device,
-                queue_family_index,
-            );
+        let b = (self.fp.get_physical_device_win32_presentation_support_khr)(
+            physical_device,
+            queue_family_index,
+        );
 
         b > 0
     }
 
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrWin32SurfaceFn::name()
+    }
+
+    #[inline]
     pub fn fp(&self) -> &vk::KhrWin32SurfaceFn {
-        &self.win32_surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/khr/xcb_surface.rs b/src/extensions/khr/xcb_surface.rs
index c01d2f3..967376e 100755
--- a/src/extensions/khr/xcb_surface.rs
+++ b/src/extensions/khr/xcb_surface.rs
@@ -1,49 +1,44 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct XcbSurface {
     handle: vk::Instance,
-    xcb_surface_fn: vk::KhrXcbSurfaceFn,
+    fp: vk::KhrXcbSurfaceFn,
 }
 
 impl XcbSurface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::KhrXcbSurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrXcbSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            xcb_surface_fn: surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrXcbSurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateXcbSurfaceKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateXcbSurfaceKHR.html>
+    #[inline]
     pub unsafe fn create_xcb_surface(
         &self,
         create_info: &vk::XcbSurfaceCreateInfoKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        self.xcb_surface_fn
-            .create_xcb_surface_khr(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut surface,
-            )
-            .result_with_success(surface)
+        (self.fp.create_xcb_surface_khr)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_xcb_presentation_support(
         &self,
         physical_device: vk::PhysicalDevice,
@@ -51,22 +46,27 @@ impl XcbSurface {
         connection: &mut vk::xcb_connection_t,
         visual_id: vk::xcb_visualid_t,
     ) -> bool {
-        let b = self
-            .xcb_surface_fn
-            .get_physical_device_xcb_presentation_support_khr(
-                physical_device,
-                queue_family_index,
-                connection,
-                visual_id,
-            );
+        let b = (self.fp.get_physical_device_xcb_presentation_support_khr)(
+            physical_device,
+            queue_family_index,
+            connection,
+            visual_id,
+        );
 
         b > 0
     }
 
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrXcbSurfaceFn::name()
+    }
+
+    #[inline]
     pub fn fp(&self) -> &vk::KhrXcbSurfaceFn {
-        &self.xcb_surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/khr/xlib_surface.rs b/src/extensions/khr/xlib_surface.rs
index 0f53c39..59ad416 100755
--- a/src/extensions/khr/xlib_surface.rs
+++ b/src/extensions/khr/xlib_surface.rs
@@ -1,49 +1,44 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct XlibSurface {
     handle: vk::Instance,
-    xlib_surface_fn: vk::KhrXlibSurfaceFn,
+    fp: vk::KhrXlibSurfaceFn,
 }
 
 impl XlibSurface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::KhrXlibSurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::KhrXlibSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            xlib_surface_fn: surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::KhrXlibSurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateXlibSurfaceKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateXlibSurfaceKHR.html>
+    #[inline]
     pub unsafe fn create_xlib_surface(
         &self,
         create_info: &vk::XlibSurfaceCreateInfoKHR,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        self.xlib_surface_fn
-            .create_xlib_surface_khr(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut surface,
-            )
-            .result_with_success(surface)
+        (self.fp.create_xlib_surface_khr)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html>
+    #[inline]
     pub unsafe fn get_physical_device_xlib_presentation_support(
         &self,
         physical_device: vk::PhysicalDevice,
@@ -51,22 +46,27 @@ impl XlibSurface {
         display: &mut vk::Display,
         visual_id: vk::VisualID,
     ) -> bool {
-        let b = self
-            .xlib_surface_fn
-            .get_physical_device_xlib_presentation_support_khr(
-                physical_device,
-                queue_family_index,
-                display,
-                visual_id,
-            );
+        let b = (self.fp.get_physical_device_xlib_presentation_support_khr)(
+            physical_device,
+            queue_family_index,
+            display,
+            visual_id,
+        );
 
         b > 0
     }
 
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::KhrXlibSurfaceFn::name()
+    }
+
+    #[inline]
     pub fn fp(&self) -> &vk::KhrXlibSurfaceFn {
-        &self.xlib_surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/mod.rs b/src/extensions/mod.rs
index b5a222c..fefba9b 100644
--- a/src/extensions/mod.rs
+++ b/src/extensions/mod.rs
@@ -1,4 +1,3 @@
-#![deny(clippy::use_self)]
 pub mod experimental;
 pub mod ext;
 pub mod khr;
diff --git a/src/extensions/mvk/ios_surface.rs b/src/extensions/mvk/ios_surface.rs
index a8491f2..8ae83e9 100755
--- a/src/extensions/mvk/ios_surface.rs
+++ b/src/extensions/mvk/ios_surface.rs
@@ -1,52 +1,53 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct IOSSurface {
     handle: vk::Instance,
-    ios_surface_fn: vk::MvkIosSurfaceFn,
+    fp: vk::MvkIosSurfaceFn,
 }
 
 impl IOSSurface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::MvkIosSurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::MvkIosSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            ios_surface_fn: surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::MvkIosSurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateIOSSurfaceMVK.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateIOSSurfaceMVK.html>
+    #[inline]
     pub unsafe fn create_ios_surface(
         &self,
         create_info: &vk::IOSSurfaceCreateInfoMVK,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        self.ios_surface_fn
-            .create_ios_surface_mvk(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut surface,
-            )
-            .result_with_success(surface)
+        (self.fp.create_ios_surface_mvk)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::MvkIosSurfaceFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::MvkIosSurfaceFn {
-        &self.ios_surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/mvk/macos_surface.rs b/src/extensions/mvk/macos_surface.rs
index 31ca0de..878829e 100755
--- a/src/extensions/mvk/macos_surface.rs
+++ b/src/extensions/mvk/macos_surface.rs
@@ -1,52 +1,53 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct MacOSSurface {
     handle: vk::Instance,
-    macos_surface_fn: vk::MvkMacosSurfaceFn,
+    fp: vk::MvkMacosSurfaceFn,
 }
 
 impl MacOSSurface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::MvkMacosSurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::MvkMacosSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            macos_surface_fn: surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::MvkMacosSurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateMacOSSurfaceMVK.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateMacOSSurfaceMVK.html>
+    #[inline]
     pub unsafe fn create_mac_os_surface(
         &self,
         create_info: &vk::MacOSSurfaceCreateInfoMVK,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        self.macos_surface_fn
-            .create_mac_os_surface_mvk(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut surface,
-            )
-            .result_with_success(surface)
+        (self.fp.create_mac_os_surface_mvk)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::MvkMacosSurfaceFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::MvkMacosSurfaceFn {
-        &self.macos_surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/nn/vi_surface.rs b/src/extensions/nn/vi_surface.rs
index e3ade6f..0aa188a 100644
--- a/src/extensions/nn/vi_surface.rs
+++ b/src/extensions/nn/vi_surface.rs
@@ -1,52 +1,53 @@
 use crate::prelude::*;
 use crate::vk;
 use crate::RawPtr;
-use crate::{EntryCustom, Instance};
+use crate::{Entry, Instance};
 use std::ffi::CStr;
 use std::mem;
 
 #[derive(Clone)]
 pub struct ViSurface {
     handle: vk::Instance,
-    vi_surface_fn: vk::NnViSurfaceFn,
+    fp: vk::NnViSurfaceFn,
 }
 
 impl ViSurface {
-    pub fn new<L>(entry: &EntryCustom<L>, instance: &Instance) -> Self {
-        let surface_fn = vk::NnViSurfaceFn::load(|name| unsafe {
-            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let handle = instance.handle();
+        let fp = vk::NnViSurfaceFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: instance.handle(),
-            vi_surface_fn: surface_fn,
-        }
+        Self { handle, fp }
     }
 
-    pub fn name() -> &'static CStr {
-        vk::NnViSurfaceFn::name()
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateViSurfaceNN.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateViSurfaceNN.html>
+    #[inline]
     pub unsafe fn create_vi_surface(
         &self,
         create_info: &vk::ViSurfaceCreateInfoNN,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::SurfaceKHR> {
         let mut surface = mem::zeroed();
-        self.vi_surface_fn
-            .create_vi_surface_nn(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut surface,
-            )
-            .result_with_success(surface)
+        (self.fp.create_vi_surface_nn)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut surface,
+        )
+        .result_with_success(surface)
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::NnViSurfaceFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::NnViSurfaceFn {
-        &self.vi_surface_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn instance(&self) -> vk::Instance {
         self.handle
     }
diff --git a/src/extensions/nv/coverage_reduction_mode.rs b/src/extensions/nv/coverage_reduction_mode.rs
new file mode 100644
index 0000000..b430477
--- /dev/null
+++ b/src/extensions/nv/coverage_reduction_mode.rs
@@ -0,0 +1,70 @@
+use crate::prelude::*;
+use crate::vk;
+use crate::{Entry, Instance};
+use std::ffi::CStr;
+use std::mem;
+
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_NV_coverage_reduction_mode.html>
+#[derive(Clone)]
+pub struct CoverageReductionMode {
+    fp: vk::NvCoverageReductionModeFn,
+}
+
+impl CoverageReductionMode {
+    pub fn new(entry: &Entry, instance: &Instance) -> Self {
+        let fp = vk::NvCoverageReductionModeFn::load(|name| unsafe {
+            mem::transmute(entry.get_instance_proc_addr(instance.handle(), name.as_ptr()))
+        });
+        Self { fp }
+    }
+
+    /// Retrieve the number of elements to pass to [`get_physical_device_supported_framebuffer_mixed_samples_combinations()`][Self::get_physical_device_supported_framebuffer_mixed_samples_combinations()]
+    #[inline]
+    pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations_len(
+        &self,
+        physical_device: vk::PhysicalDevice,
+    ) -> VkResult<usize> {
+        let mut count = 0;
+        (self
+            .fp
+            .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)(
+            physical_device,
+            &mut count,
+            std::ptr::null_mut(),
+        )
+        .result_with_success(count as usize)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html>
+    ///
+    /// Call [`get_physical_device_supported_framebuffer_mixed_samples_combinations_len()`][Self::get_physical_device_supported_framebuffer_mixed_samples_combinations_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        out: &mut [vk::FramebufferMixedSamplesCombinationNV],
+    ) -> VkResult<()> {
+        let mut count = out.len() as u32;
+        (self
+            .fp
+            .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)(
+            physical_device,
+            &mut count,
+            out.as_mut_ptr(),
+        )
+        .result()?;
+        assert_eq!(count as usize, out.len());
+        Ok(())
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
+        vk::NvCoverageReductionModeFn::name()
+    }
+
+    #[inline]
+    pub fn fp(&self) -> &vk::NvCoverageReductionModeFn {
+        &self.fp
+    }
+}
diff --git a/src/extensions/nv/device_diagnostic_checkpoints.rs b/src/extensions/nv/device_diagnostic_checkpoints.rs
index 8465aba..ce43d04 100644
--- a/src/extensions/nv/device_diagnostic_checkpoints.rs
+++ b/src/extensions/nv/device_diagnostic_checkpoints.rs
@@ -4,53 +4,60 @@ use std::ffi::CStr;
 use std::mem;
 use std::os::raw::c_void;
 
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_NV_device_diagnostic_checkpoints.html>
 #[derive(Clone)]
 pub struct DeviceDiagnosticCheckpoints {
-    device_diagnostic_checkpoints_fn: vk::NvDeviceDiagnosticCheckpointsFn,
+    fp: vk::NvDeviceDiagnosticCheckpointsFn,
 }
 
 impl DeviceDiagnosticCheckpoints {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let device_diagnostic_checkpoints_fn =
-            vk::NvDeviceDiagnosticCheckpointsFn::load(|name| unsafe {
-                mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
-            });
-        Self {
-            device_diagnostic_checkpoints_fn,
-        }
+        let fp = vk::NvDeviceDiagnosticCheckpointsFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        });
+        Self { fp }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetCheckpointNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdSetCheckpointNV.html>
+    #[inline]
     pub unsafe fn cmd_set_checkpoint(
         &self,
         command_buffer: vk::CommandBuffer,
         p_checkpoint_marker: *const c_void,
     ) {
-        self.device_diagnostic_checkpoints_fn
-            .cmd_set_checkpoint_nv(command_buffer, p_checkpoint_marker);
+        (self.fp.cmd_set_checkpoint_nv)(command_buffer, p_checkpoint_marker);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetQueueCheckpointDataNV.html>"]
-    pub unsafe fn get_queue_checkpoint_data(&self, queue: vk::Queue) -> Vec<vk::CheckpointDataNV> {
-        let mut checkpoint_data_count: u32 = 0;
-        self.device_diagnostic_checkpoints_fn
-            .get_queue_checkpoint_data_nv(queue, &mut checkpoint_data_count, std::ptr::null_mut());
-        let mut checkpoint_data: Vec<vk::CheckpointDataNV> =
-            vec![vk::CheckpointDataNV::default(); checkpoint_data_count as _];
-        self.device_diagnostic_checkpoints_fn
-            .get_queue_checkpoint_data_nv(
-                queue,
-                &mut checkpoint_data_count,
-                checkpoint_data.as_mut_ptr(),
-            );
-        checkpoint_data
+    /// Retrieve the number of elements to pass to [`get_queue_checkpoint_data()`][Self::get_queue_checkpoint_data()]
+    #[inline]
+    pub unsafe fn get_queue_checkpoint_data_len(&self, queue: vk::Queue) -> usize {
+        let mut count = 0;
+        (self.fp.get_queue_checkpoint_data_nv)(queue, &mut count, std::ptr::null_mut());
+        count as usize
     }
 
-    pub fn name() -> &'static CStr {
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetQueueCheckpointDataNV.html>
+    ///
+    /// Call [`get_queue_checkpoint_data_len()`][Self::get_queue_checkpoint_data_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn get_queue_checkpoint_data(
+        &self,
+        queue: vk::Queue,
+        out: &mut [vk::CheckpointDataNV],
+    ) {
+        let mut count = out.len() as u32;
+        (self.fp.get_queue_checkpoint_data_nv)(queue, &mut count, out.as_mut_ptr());
+        assert_eq!(count as usize, out.len());
+    }
+
+    #[inline]
+    pub const fn name() -> &'static CStr {
         vk::NvDeviceDiagnosticCheckpointsFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::NvDeviceDiagnosticCheckpointsFn {
-        &self.device_diagnostic_checkpoints_fn
+        &self.fp
     }
 }
diff --git a/src/extensions/nv/mesh_shader.rs b/src/extensions/nv/mesh_shader.rs
index 95e2375..14ef8d4 100755
--- a/src/extensions/nv/mesh_shader.rs
+++ b/src/extensions/nv/mesh_shader.rs
@@ -5,29 +5,30 @@ use std::mem;
 
 #[derive(Clone)]
 pub struct MeshShader {
-    mesh_shader_fn: vk::NvMeshShaderFn,
+    fp: vk::NvMeshShaderFn,
 }
 
 impl MeshShader {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let mesh_shader_fn = vk::NvMeshShaderFn::load(|name| unsafe {
+        let fp = vk::NvMeshShaderFn::load(|name| unsafe {
             mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
         });
-        Self { mesh_shader_fn }
+        Self { fp }
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawMeshTasksNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksNV.html>
+    #[inline]
     pub unsafe fn cmd_draw_mesh_tasks(
         &self,
         command_buffer: vk::CommandBuffer,
         task_count: u32,
         first_task: u32,
     ) {
-        self.mesh_shader_fn
-            .cmd_draw_mesh_tasks_nv(command_buffer, task_count, first_task);
+        (self.fp.cmd_draw_mesh_tasks_nv)(command_buffer, task_count, first_task);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawMeshTasksIndirectNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectNV.html>
+    #[inline]
     pub unsafe fn cmd_draw_mesh_tasks_indirect(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -36,7 +37,7 @@ impl MeshShader {
         draw_count: u32,
         stride: u32,
     ) {
-        self.mesh_shader_fn.cmd_draw_mesh_tasks_indirect_nv(
+        (self.fp.cmd_draw_mesh_tasks_indirect_nv)(
             command_buffer,
             buffer,
             offset,
@@ -45,7 +46,8 @@ impl MeshShader {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawMeshTasksIndirectCountNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdDrawMeshTasksIndirectCountNV.html>
+    #[inline]
     pub unsafe fn cmd_draw_mesh_tasks_indirect_count(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -56,7 +58,7 @@ impl MeshShader {
         max_draw_count: u32,
         stride: u32,
     ) {
-        self.mesh_shader_fn.cmd_draw_mesh_tasks_indirect_count_nv(
+        (self.fp.cmd_draw_mesh_tasks_indirect_count_nv)(
             command_buffer,
             buffer,
             offset,
@@ -67,11 +69,13 @@ impl MeshShader {
         );
     }
 
-    pub fn name() -> &'static CStr {
+    #[inline]
+    pub const fn name() -> &'static CStr {
         vk::NvMeshShaderFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::NvMeshShaderFn {
-        &self.mesh_shader_fn
+        &self.fp
     }
 }
diff --git a/src/extensions/nv/mod.rs b/src/extensions/nv/mod.rs
index 47b952f..bfde37a 100644
--- a/src/extensions/nv/mod.rs
+++ b/src/extensions/nv/mod.rs
@@ -1,7 +1,9 @@
+pub use self::coverage_reduction_mode::CoverageReductionMode;
 pub use self::device_diagnostic_checkpoints::DeviceDiagnosticCheckpoints;
 pub use self::mesh_shader::MeshShader;
 pub use self::ray_tracing::RayTracing;
 
+mod coverage_reduction_mode;
 mod device_diagnostic_checkpoints;
 mod mesh_shader;
 mod ray_tracing;
diff --git a/src/extensions/nv/ray_tracing.rs b/src/extensions/nv/ray_tracing.rs
index 6b430a2..d97ec85 100755
--- a/src/extensions/nv/ray_tracing.rs
+++ b/src/extensions/nv/ray_tracing.rs
@@ -8,20 +8,19 @@ use std::mem;
 #[derive(Clone)]
 pub struct RayTracing {
     handle: vk::Device,
-    ray_tracing_fn: vk::NvRayTracingFn,
+    fp: vk::NvRayTracingFn,
 }
 
 impl RayTracing {
     pub fn new(instance: &Instance, device: &Device) -> Self {
-        let ray_tracing_fn = vk::NvRayTracingFn::load(|name| unsafe {
-            mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
+        let handle = device.handle();
+        let fp = vk::NvRayTracingFn::load(|name| unsafe {
+            mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
         });
-        Self {
-            handle: device.handle(),
-            ray_tracing_fn,
-        }
+        Self { handle, fp }
     }
 
+    #[inline]
     pub unsafe fn get_properties(
         instance: &Instance,
         pdevice: vk::PhysicalDevice,
@@ -34,66 +33,68 @@ impl RayTracing {
         props_rt
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateAccelerationStructureNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateAccelerationStructureNV.html>
+    #[inline]
     pub unsafe fn create_acceleration_structure(
         &self,
         create_info: &vk::AccelerationStructureCreateInfoNV,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<vk::AccelerationStructureNV> {
         let mut accel_struct = mem::zeroed();
-        self.ray_tracing_fn
-            .create_acceleration_structure_nv(
-                self.handle,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut accel_struct,
-            )
-            .result_with_success(accel_struct)
+        (self.fp.create_acceleration_structure_nv)(
+            self.handle,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut accel_struct,
+        )
+        .result_with_success(accel_struct)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyAccelerationStructureNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyAccelerationStructureNV.html>
+    #[inline]
     pub unsafe fn destroy_acceleration_structure(
         &self,
         accel_struct: vk::AccelerationStructureNV,
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) {
-        self.ray_tracing_fn.destroy_acceleration_structure_nv(
+        (self.fp.destroy_acceleration_structure_nv)(
             self.handle,
             accel_struct,
             allocation_callbacks.as_raw_ptr(),
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html>
+    #[inline]
     pub unsafe fn get_acceleration_structure_memory_requirements(
         &self,
         info: &vk::AccelerationStructureMemoryRequirementsInfoNV,
     ) -> vk::MemoryRequirements2KHR {
         let mut requirements = mem::zeroed();
-        self.ray_tracing_fn
-            .get_acceleration_structure_memory_requirements_nv(
-                self.handle,
-                info,
-                &mut requirements,
-            );
+        (self.fp.get_acceleration_structure_memory_requirements_nv)(
+            self.handle,
+            info,
+            &mut requirements,
+        );
         requirements
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindAccelerationStructureMemoryNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkBindAccelerationStructureMemoryNV.html>
+    #[inline]
     pub unsafe fn bind_acceleration_structure_memory(
         &self,
         bind_info: &[vk::BindAccelerationStructureMemoryInfoNV],
     ) -> VkResult<()> {
-        self.ray_tracing_fn
-            .bind_acceleration_structure_memory_nv(
-                self.handle,
-                bind_info.len() as u32,
-                bind_info.as_ptr(),
-            )
-            .into()
+        (self.fp.bind_acceleration_structure_memory_nv)(
+            self.handle,
+            bind_info.len() as u32,
+            bind_info.as_ptr(),
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBuildAccelerationStructureNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdBuildAccelerationStructureNV.html>
+    #[inline]
     pub unsafe fn cmd_build_acceleration_structure(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -106,7 +107,7 @@ impl RayTracing {
         scratch: vk::Buffer,
         scratch_offset: vk::DeviceSize,
     ) {
-        self.ray_tracing_fn.cmd_build_acceleration_structure_nv(
+        (self.fp.cmd_build_acceleration_structure_nv)(
             command_buffer,
             info,
             instance_data,
@@ -119,7 +120,8 @@ impl RayTracing {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyAccelerationStructureNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdCopyAccelerationStructureNV.html>
+    #[inline]
     pub unsafe fn cmd_copy_acceleration_structure(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -127,11 +129,11 @@ impl RayTracing {
         src: vk::AccelerationStructureNV,
         mode: vk::CopyAccelerationStructureModeNV,
     ) {
-        self.ray_tracing_fn
-            .cmd_copy_acceleration_structure_nv(command_buffer, dst, src, mode);
+        (self.fp.cmd_copy_acceleration_structure_nv)(command_buffer, dst, src, mode);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdTraceRaysNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdTraceRaysNV.html>
+    #[inline]
     pub unsafe fn cmd_trace_rays(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -150,7 +152,7 @@ impl RayTracing {
         height: u32,
         depth: u32,
     ) {
-        self.ray_tracing_fn.cmd_trace_rays_nv(
+        (self.fp.cmd_trace_rays_nv)(
             command_buffer,
             raygen_shader_binding_table_buffer,
             raygen_shader_binding_offset,
@@ -169,7 +171,8 @@ impl RayTracing {
         );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRayTracingPipelinesNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateRayTracingPipelinesNV.html>
+    #[inline]
     pub unsafe fn create_ray_tracing_pipelines(
         &self,
         pipeline_cache: vk::PipelineCache,
@@ -177,19 +180,19 @@ impl RayTracing {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<Vec<vk::Pipeline>> {
         let mut pipelines = vec![mem::zeroed(); create_info.len()];
-        self.ray_tracing_fn
-            .create_ray_tracing_pipelines_nv(
-                self.handle,
-                pipeline_cache,
-                create_info.len() as u32,
-                create_info.as_ptr(),
-                allocation_callbacks.as_raw_ptr(),
-                pipelines.as_mut_ptr(),
-            )
-            .result_with_success(pipelines)
+        (self.fp.create_ray_tracing_pipelines_nv)(
+            self.handle,
+            pipeline_cache,
+            create_info.len() as u32,
+            create_info.as_ptr(),
+            allocation_callbacks.as_raw_ptr(),
+            pipelines.as_mut_ptr(),
+        )
+        .result_with_success(pipelines)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRayTracingShaderGroupHandlesNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetRayTracingShaderGroupHandlesNV.html>
+    #[inline]
     pub unsafe fn get_ray_tracing_shader_group_handles(
         &self,
         pipeline: vk::Pipeline,
@@ -197,36 +200,36 @@ impl RayTracing {
         group_count: u32,
         data: &mut [u8],
     ) -> VkResult<()> {
-        self.ray_tracing_fn
-            .get_ray_tracing_shader_group_handles_nv(
-                self.handle,
-                pipeline,
-                first_group,
-                group_count,
-                data.len(),
-                data.as_mut_ptr() as *mut std::ffi::c_void,
-            )
-            .into()
+        (self.fp.get_ray_tracing_shader_group_handles_nv)(
+            self.handle,
+            pipeline,
+            first_group,
+            group_count,
+            data.len(),
+            data.as_mut_ptr().cast(),
+        )
+        .result()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetAccelerationStructureHandleNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetAccelerationStructureHandleNV.html>
+    #[inline]
     pub unsafe fn get_acceleration_structure_handle(
         &self,
         accel_struct: vk::AccelerationStructureNV,
     ) -> VkResult<u64> {
         let mut handle: u64 = 0;
         let handle_ptr: *mut u64 = &mut handle;
-        self.ray_tracing_fn
-            .get_acceleration_structure_handle_nv(
-                self.handle,
-                accel_struct,
-                std::mem::size_of::<u64>(),
-                handle_ptr as *mut std::ffi::c_void,
-            )
-            .result_with_success(handle)
+        (self.fp.get_acceleration_structure_handle_nv)(
+            self.handle,
+            accel_struct,
+            std::mem::size_of::<u64>(),
+            handle_ptr.cast(),
+        )
+        .result_with_success(handle)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html>
+    #[inline]
     pub unsafe fn cmd_write_acceleration_structures_properties(
         &self,
         command_buffer: vk::CommandBuffer,
@@ -235,32 +238,33 @@ impl RayTracing {
         query_pool: vk::QueryPool,
         first_query: u32,
     ) {
-        self.ray_tracing_fn
-            .cmd_write_acceleration_structures_properties_nv(
-                command_buffer,
-                structures.len() as u32,
-                structures.as_ptr(),
-                query_type,
-                query_pool,
-                first_query,
-            );
+        (self.fp.cmd_write_acceleration_structures_properties_nv)(
+            command_buffer,
+            structures.len() as u32,
+            structures.as_ptr(),
+            query_type,
+            query_pool,
+            first_query,
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCompileDeferredNV.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCompileDeferredNV.html>
+    #[inline]
     pub unsafe fn compile_deferred(&self, pipeline: vk::Pipeline, shader: u32) -> VkResult<()> {
-        self.ray_tracing_fn
-            .compile_deferred_nv(self.handle, pipeline, shader)
-            .into()
+        (self.fp.compile_deferred_nv)(self.handle, pipeline, shader).result()
     }
 
-    pub fn name() -> &'static CStr {
+    #[inline]
+    pub const fn name() -> &'static CStr {
         vk::NvRayTracingFn::name()
     }
 
+    #[inline]
     pub fn fp(&self) -> &vk::NvRayTracingFn {
-        &self.ray_tracing_fn
+        &self.fp
     }
 
+    #[inline]
     pub fn device(&self) -> vk::Device {
         self.handle
     }
diff --git a/src/instance.rs b/src/instance.rs
index 8328594..da3ef99 100644
--- a/src/instance.rs
+++ b/src/instance.rs
@@ -1,3 +1,5 @@
+#[cfg(doc)]
+use super::Entry;
 use crate::device::Device;
 use crate::prelude::*;
 use crate::vk;
@@ -6,7 +8,7 @@ use std::mem;
 use std::os::raw::c_char;
 use std::ptr;
 
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstance.html>"]
+/// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstance.html>
 #[derive(Clone)]
 pub struct Instance {
     pub(crate) handle: vk::Instance,
@@ -14,31 +16,80 @@ pub struct Instance {
     pub(crate) instance_fn_1_0: vk::InstanceFnV1_0,
     pub(crate) instance_fn_1_1: vk::InstanceFnV1_1,
     pub(crate) instance_fn_1_2: vk::InstanceFnV1_2,
+    pub(crate) instance_fn_1_3: vk::InstanceFnV1_3,
 }
 
 impl Instance {
     pub unsafe fn load(static_fn: &vk::StaticFn, instance: vk::Instance) -> Self {
         let load_fn = |name: &std::ffi::CStr| {
-            mem::transmute(static_fn.get_instance_proc_addr(instance, name.as_ptr()))
+            mem::transmute((static_fn.get_instance_proc_addr)(instance, name.as_ptr()))
         };
 
-        Instance {
+        Self {
             handle: instance,
 
             instance_fn_1_0: vk::InstanceFnV1_0::load(load_fn),
             instance_fn_1_1: vk::InstanceFnV1_1::load(load_fn),
             instance_fn_1_2: vk::InstanceFnV1_2::load(load_fn),
+            instance_fn_1_3: vk::InstanceFnV1_3::load(load_fn),
         }
     }
 
+    #[inline]
     pub fn handle(&self) -> vk::Instance {
         self.handle
     }
 }
 
+/// Vulkan core 1.3
+#[allow(non_camel_case_types)]
+impl Instance {
+    #[inline]
+    pub fn fp_v1_3(&self) -> &vk::InstanceFnV1_3 {
+        &self.instance_fn_1_3
+    }
+
+    /// Retrieve the number of elements to pass to [`get_physical_device_tool_properties()`][Self::get_physical_device_tool_properties()]
+    #[inline]
+    pub unsafe fn get_physical_device_tool_properties_len(
+        &self,
+        physical_device: vk::PhysicalDevice,
+    ) -> VkResult<usize> {
+        let mut count = 0;
+        (self.instance_fn_1_3.get_physical_device_tool_properties)(
+            physical_device,
+            &mut count,
+            ptr::null_mut(),
+        )
+        .result_with_success(count as usize)
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceToolProperties.html>
+    ///
+    /// Call [`get_physical_device_tool_properties_len()`][Self::get_physical_device_tool_properties_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn get_physical_device_tool_properties(
+        &self,
+        physical_device: vk::PhysicalDevice,
+        out: &mut [vk::PhysicalDeviceToolProperties],
+    ) -> VkResult<()> {
+        let mut count = out.len() as u32;
+        (self.instance_fn_1_3.get_physical_device_tool_properties)(
+            physical_device,
+            &mut count,
+            out.as_mut_ptr(),
+        )
+        .result()?;
+        assert_eq!(count as usize, out.len());
+        Ok(())
+    }
+}
+
 /// Vulkan core 1.2
 #[allow(non_camel_case_types)]
 impl Instance {
+    #[inline]
     pub fn fp_v1_2(&self) -> &vk::InstanceFnV1_2 {
         &self.instance_fn_1_2
     }
@@ -47,208 +98,257 @@ impl Instance {
 /// Vulkan core 1.1
 #[allow(non_camel_case_types)]
 impl Instance {
+    #[inline]
     pub fn fp_v1_1(&self) -> &vk::InstanceFnV1_1 {
         &self.instance_fn_1_1
     }
 
+    /// Retrieve the number of elements to pass to [`enumerate_physical_device_groups()`][Self::enumerate_physical_device_groups()]
+    #[inline]
     pub unsafe fn enumerate_physical_device_groups_len(&self) -> VkResult<usize> {
         let mut group_count = 0;
-        self.instance_fn_1_1
-            .enumerate_physical_device_groups(self.handle(), &mut group_count, ptr::null_mut())
-            .result_with_success(group_count as usize)
+        (self.instance_fn_1_1.enumerate_physical_device_groups)(
+            self.handle(),
+            &mut group_count,
+            ptr::null_mut(),
+        )
+        .result_with_success(group_count as usize)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDeviceGroups.html>"]
-    pub fn enumerate_physical_device_groups(
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumeratePhysicalDeviceGroups.html>
+    ///
+    /// Call [`enumerate_physical_device_groups_len()`][Self::enumerate_physical_device_groups_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
+    pub unsafe fn enumerate_physical_device_groups(
         &self,
         out: &mut [vk::PhysicalDeviceGroupProperties],
     ) -> VkResult<()> {
-        unsafe {
-            let mut group_count = out.len() as u32;
-            self.instance_fn_1_1
-                .enumerate_physical_device_groups(self.handle(), &mut group_count, out.as_mut_ptr())
-                .into()
-        }
-    }
-
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures2.html>"]
+        let mut count = out.len() as u32;
+        (self.instance_fn_1_1.enumerate_physical_device_groups)(
+            self.handle(),
+            &mut count,
+            out.as_mut_ptr(),
+        )
+        .result()?;
+        assert_eq!(count as usize, out.len());
+        Ok(())
+    }
+
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFeatures2.html>
+    #[inline]
     pub unsafe fn get_physical_device_features2(
         &self,
         physical_device: vk::PhysicalDevice,
         features: &mut vk::PhysicalDeviceFeatures2,
     ) {
-        self.instance_fn_1_1
-            .get_physical_device_features2(physical_device, features);
+        (self.instance_fn_1_1.get_physical_device_features2)(physical_device, features);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceProperties2.html>
+    #[inline]
     pub unsafe fn get_physical_device_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         prop: &mut vk::PhysicalDeviceProperties2,
     ) {
-        self.instance_fn_1_1
-            .get_physical_device_properties2(physical_device, prop);
+        (self.instance_fn_1_1.get_physical_device_properties2)(physical_device, prop);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFormatProperties2.html>
+    #[inline]
     pub unsafe fn get_physical_device_format_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         format: vk::Format,
         out: &mut vk::FormatProperties2,
     ) {
-        self.instance_fn_1_1
-            .get_physical_device_format_properties2(physical_device, format, out);
+        (self.instance_fn_1_1.get_physical_device_format_properties2)(physical_device, format, out);
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2.html>
+    #[inline]
     pub unsafe fn get_physical_device_image_format_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         format_info: &vk::PhysicalDeviceImageFormatInfo2,
         image_format_prop: &mut vk::ImageFormatProperties2,
     ) -> VkResult<()> {
-        self.instance_fn_1_1
-            .get_physical_device_image_format_properties2(
-                physical_device,
-                format_info,
-                image_format_prop,
-            )
-            .into()
+        (self
+            .instance_fn_1_1
+            .get_physical_device_image_format_properties2)(
+            physical_device,
+            format_info,
+            image_format_prop,
+        )
+        .result()
     }
 
+    /// Retrieve the number of elements to pass to [`get_physical_device_queue_family_properties2()`][Self::get_physical_device_queue_family_properties2()]
+    #[inline]
     pub unsafe fn get_physical_device_queue_family_properties2_len(
         &self,
         physical_device: vk::PhysicalDevice,
     ) -> usize {
         let mut queue_count = 0;
-        self.instance_fn_1_1
-            .get_physical_device_queue_family_properties2(
-                physical_device,
-                &mut queue_count,
-                ptr::null_mut(),
-            );
+        (self
+            .instance_fn_1_1
+            .get_physical_device_queue_family_properties2)(
+            physical_device,
+            &mut queue_count,
+            ptr::null_mut(),
+        );
         queue_count as usize
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html>
+    ///
+    /// Call [`get_physical_device_queue_family_properties2_len()`][Self::get_physical_device_queue_family_properties2_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
     pub unsafe fn get_physical_device_queue_family_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
-        queue_family_props: &mut [vk::QueueFamilyProperties2],
+        out: &mut [vk::QueueFamilyProperties2],
     ) {
-        let mut queue_count = queue_family_props.len() as u32;
-        self.instance_fn_1_1
-            .get_physical_device_queue_family_properties2(
-                physical_device,
-                &mut queue_count,
-                queue_family_props.as_mut_ptr(),
-            );
+        let mut count = out.len() as u32;
+        (self
+            .instance_fn_1_1
+            .get_physical_device_queue_family_properties2)(
+            physical_device,
+            &mut count,
+            out.as_mut_ptr(),
+        );
+        assert_eq!(count as usize, out.len());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2.html>
+    #[inline]
     pub unsafe fn get_physical_device_memory_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         out: &mut vk::PhysicalDeviceMemoryProperties2,
     ) {
-        self.instance_fn_1_1
-            .get_physical_device_memory_properties2(physical_device, out);
+        (self.instance_fn_1_1.get_physical_device_memory_properties2)(physical_device, out);
     }
 
+    /// Retrieve the number of elements to pass to [`get_physical_device_sparse_image_format_properties2()`][Self::get_physical_device_sparse_image_format_properties2()]
+    #[inline]
     pub unsafe fn get_physical_device_sparse_image_format_properties2_len(
         &self,
         physical_device: vk::PhysicalDevice,
         format_info: &vk::PhysicalDeviceSparseImageFormatInfo2,
     ) -> usize {
         let mut format_count = 0;
-        self.instance_fn_1_1
-            .get_physical_device_sparse_image_format_properties2(
-                physical_device,
-                format_info,
-                &mut format_count,
-                ptr::null_mut(),
-            );
+        (self
+            .instance_fn_1_1
+            .get_physical_device_sparse_image_format_properties2)(
+            physical_device,
+            format_info,
+            &mut format_count,
+            ptr::null_mut(),
+        );
         format_count as usize
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html>
+    ///
+    /// Call [`get_physical_device_sparse_image_format_properties2_len()`][Self::get_physical_device_sparse_image_format_properties2_len()] to query the number of elements to pass to `out`.
+    /// Be sure to [`Default::default()`]-initialize these elements and optionally set their `p_next` pointer.
+    #[inline]
     pub unsafe fn get_physical_device_sparse_image_format_properties2(
         &self,
         physical_device: vk::PhysicalDevice,
         format_info: &vk::PhysicalDeviceSparseImageFormatInfo2,
         out: &mut [vk::SparseImageFormatProperties2],
     ) {
-        let mut format_count = out.len() as u32;
-        self.instance_fn_1_1
-            .get_physical_device_sparse_image_format_properties2(
-                physical_device,
-                format_info,
-                &mut format_count,
-                out.as_mut_ptr(),
-            );
+        let mut count = out.len() as u32;
+        (self
+            .instance_fn_1_1
+            .get_physical_device_sparse_image_format_properties2)(
+            physical_device,
+            format_info,
+            &mut count,
+            out.as_mut_ptr(),
+        );
+        assert_eq!(count as usize, out.len());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalBufferProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceExternalBufferProperties.html>
+    #[inline]
     pub unsafe fn get_physical_device_external_buffer_properties(
         &self,
         physical_device: vk::PhysicalDevice,
         external_buffer_info: &vk::PhysicalDeviceExternalBufferInfo,
         out: &mut vk::ExternalBufferProperties,
     ) {
-        self.instance_fn_1_1
-            .get_physical_device_external_buffer_properties(
-                physical_device,
-                external_buffer_info,
-                out,
-            );
+        (self
+            .instance_fn_1_1
+            .get_physical_device_external_buffer_properties)(
+            physical_device,
+            external_buffer_info,
+            out,
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalFenceProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceExternalFenceProperties.html>
+    #[inline]
     pub unsafe fn get_physical_device_external_fence_properties(
         &self,
         physical_device: vk::PhysicalDevice,
         external_fence_info: &vk::PhysicalDeviceExternalFenceInfo,
         out: &mut vk::ExternalFenceProperties,
     ) {
-        self.instance_fn_1_1
-            .get_physical_device_external_fence_properties(
-                physical_device,
-                external_fence_info,
-                out,
-            );
+        (self
+            .instance_fn_1_1
+            .get_physical_device_external_fence_properties)(
+            physical_device,
+            external_fence_info,
+            out,
+        );
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html>
+    #[inline]
     pub unsafe fn get_physical_device_external_semaphore_properties(
         &self,
         physical_device: vk::PhysicalDevice,
         external_semaphore_info: &vk::PhysicalDeviceExternalSemaphoreInfo,
         out: &mut vk::ExternalSemaphoreProperties,
     ) {
-        self.instance_fn_1_1
-            .get_physical_device_external_semaphore_properties(
-                physical_device,
-                external_semaphore_info,
-                out,
-            );
+        (self
+            .instance_fn_1_1
+            .get_physical_device_external_semaphore_properties)(
+            physical_device,
+            external_semaphore_info,
+            out,
+        );
     }
 }
 
 /// Vulkan core 1.0
 #[allow(non_camel_case_types)]
 impl Instance {
+    #[inline]
     pub fn fp_v1_0(&self) -> &vk::InstanceFnV1_0 {
         &self.instance_fn_1_0
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDevice.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkCreateDevice.html>
     ///
     /// # Safety
-    /// In order for the created [`Device`] to be valid for the duration of its
-    /// usage, the [`Instance`] this was called on must be dropped later than the
-    /// resulting [`Device`].
+    ///
+    /// There is a [parent/child relation] between [`Instance`] and the resulting [`Device`].  The
+    /// application must not [destroy][Instance::destroy_instance()] the parent [`Instance`] object
+    /// before first [destroying][Device::destroy_device()] the returned [`Device`] child object.
+    /// [`Device`] does _not_ implement [drop][drop()] semantics and can only be destroyed via
+    /// [`destroy_device()`][Device::destroy_device()].
+    ///
+    /// See the [`Entry::create_instance()`] documentation for more destruction ordering rules on
+    /// [`Instance`].
+    ///
+    /// [parent/child relation]: https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#fundamentals-objectmodel-lifetime
+    #[inline]
     pub unsafe fn create_device(
         &self,
         physical_device: vk::PhysicalDevice,
@@ -256,40 +356,41 @@ impl Instance {
         allocation_callbacks: Option<&vk::AllocationCallbacks>,
     ) -> VkResult<Device> {
         let mut device = mem::zeroed();
-        self.instance_fn_1_0
-            .create_device(
-                physical_device,
-                create_info,
-                allocation_callbacks.as_raw_ptr(),
-                &mut device,
-            )
-            .result()?;
+        (self.instance_fn_1_0.create_device)(
+            physical_device,
+            create_info,
+            allocation_callbacks.as_raw_ptr(),
+            &mut device,
+        )
+        .result()?;
         Ok(Device::load(&self.instance_fn_1_0, device))
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceProcAddr.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetDeviceProcAddr.html>
+    #[inline]
     pub unsafe fn get_device_proc_addr(
         &self,
         device: vk::Device,
         p_name: *const c_char,
     ) -> vk::PFN_vkVoidFunction {
-        self.instance_fn_1_0.get_device_proc_addr(device, p_name)
+        (self.instance_fn_1_0.get_device_proc_addr)(device, p_name)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyInstance.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkDestroyInstance.html>
+    #[inline]
     pub unsafe fn destroy_instance(&self, allocation_callbacks: Option<&vk::AllocationCallbacks>) {
-        self.instance_fn_1_0
-            .destroy_instance(self.handle(), allocation_callbacks.as_raw_ptr());
+        (self.instance_fn_1_0.destroy_instance)(self.handle(), allocation_callbacks.as_raw_ptr());
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFormatProperties.html>
+    #[inline]
     pub unsafe fn get_physical_device_format_properties(
         &self,
         physical_device: vk::PhysicalDevice,
         format: vk::Format,
     ) -> vk::FormatProperties {
         let mut format_prop = mem::zeroed();
-        self.instance_fn_1_0.get_physical_device_format_properties(
+        (self.instance_fn_1_0.get_physical_device_format_properties)(
             physical_device,
             format,
             &mut format_prop,
@@ -297,7 +398,8 @@ impl Instance {
         format_prop
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties.html>
+    #[inline]
     pub unsafe fn get_physical_device_image_format_properties(
         &self,
         physical_device: vk::PhysicalDevice,
@@ -308,81 +410,90 @@ impl Instance {
         flags: vk::ImageCreateFlags,
     ) -> VkResult<vk::ImageFormatProperties> {
         let mut image_format_prop = mem::zeroed();
-        self.instance_fn_1_0
-            .get_physical_device_image_format_properties(
-                physical_device,
-                format,
-                typ,
-                tiling,
-                usage,
-                flags,
-                &mut image_format_prop,
-            )
-            .result_with_success(image_format_prop)
+        (self
+            .instance_fn_1_0
+            .get_physical_device_image_format_properties)(
+            physical_device,
+            format,
+            typ,
+            tiling,
+            usage,
+            flags,
+            &mut image_format_prop,
+        )
+        .result_with_success(image_format_prop)
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceMemoryProperties.html>
+    #[inline]
     pub unsafe fn get_physical_device_memory_properties(
         &self,
         physical_device: vk::PhysicalDevice,
     ) -> vk::PhysicalDeviceMemoryProperties {
         let mut memory_prop = mem::zeroed();
-        self.instance_fn_1_0
-            .get_physical_device_memory_properties(physical_device, &mut memory_prop);
+        (self.instance_fn_1_0.get_physical_device_memory_properties)(
+            physical_device,
+            &mut memory_prop,
+        );
         memory_prop
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceProperties.html>
+    #[inline]
     pub unsafe fn get_physical_device_properties(
         &self,
         physical_device: vk::PhysicalDevice,
     ) -> vk::PhysicalDeviceProperties {
         let mut prop = mem::zeroed();
-        self.instance_fn_1_0
-            .get_physical_device_properties(physical_device, &mut prop);
+        (self.instance_fn_1_0.get_physical_device_properties)(physical_device, &mut prop);
         prop
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html>
+    #[inline]
     pub unsafe fn get_physical_device_queue_family_properties(
         &self,
         physical_device: vk::PhysicalDevice,
     ) -> Vec<vk::QueueFamilyProperties> {
         read_into_uninitialized_vector(|count, data| {
-            self.instance_fn_1_0
-                .get_physical_device_queue_family_properties(physical_device, count, data);
+            (self
+                .instance_fn_1_0
+                .get_physical_device_queue_family_properties)(
+                physical_device, count, data
+            );
             vk::Result::SUCCESS
         })
         // The closure always returns SUCCESS
         .unwrap()
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceFeatures.html>
+    #[inline]
     pub unsafe fn get_physical_device_features(
         &self,
         physical_device: vk::PhysicalDevice,
     ) -> vk::PhysicalDeviceFeatures {
         let mut prop = mem::zeroed();
-        self.instance_fn_1_0
-            .get_physical_device_features(physical_device, &mut prop);
+        (self.instance_fn_1_0.get_physical_device_features)(physical_device, &mut prop);
         prop
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDevices.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumeratePhysicalDevices.html>
+    #[inline]
     pub unsafe fn enumerate_physical_devices(&self) -> VkResult<Vec<vk::PhysicalDevice>> {
         read_into_uninitialized_vector(|count, data| {
-            self.instance_fn_1_0
-                .enumerate_physical_devices(self.handle(), count, data)
+            (self.instance_fn_1_0.enumerate_physical_devices)(self.handle(), count, data)
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateDeviceExtensionProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateDeviceExtensionProperties.html>
+    #[inline]
     pub unsafe fn enumerate_device_extension_properties(
         &self,
         device: vk::PhysicalDevice,
     ) -> VkResult<Vec<vk::ExtensionProperties>> {
         read_into_uninitialized_vector(|count, data| {
-            self.instance_fn_1_0.enumerate_device_extension_properties(
+            (self.instance_fn_1_0.enumerate_device_extension_properties)(
                 device,
                 ptr::null(),
                 count,
@@ -391,18 +502,19 @@ impl Instance {
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateDeviceLayerProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateDeviceLayerProperties.html>
+    #[inline]
     pub unsafe fn enumerate_device_layer_properties(
         &self,
         device: vk::PhysicalDevice,
     ) -> VkResult<Vec<vk::LayerProperties>> {
         read_into_uninitialized_vector(|count, data| {
-            self.instance_fn_1_0
-                .enumerate_device_layer_properties(device, count, data)
+            (self.instance_fn_1_0.enumerate_device_layer_properties)(device, count, data)
         })
     }
 
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html>"]
+    /// <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html>
+    #[inline]
     pub unsafe fn get_physical_device_sparse_image_format_properties(
         &self,
         physical_device: vk::PhysicalDevice,
@@ -413,17 +525,18 @@ impl Instance {
         tiling: vk::ImageTiling,
     ) -> Vec<vk::SparseImageFormatProperties> {
         read_into_uninitialized_vector(|count, data| {
-            self.instance_fn_1_0
-                .get_physical_device_sparse_image_format_properties(
-                    physical_device,
-                    format,
-                    typ,
-                    samples,
-                    usage,
-                    tiling,
-                    count,
-                    data,
-                );
+            (self
+                .instance_fn_1_0
+                .get_physical_device_sparse_image_format_properties)(
+                physical_device,
+                format,
+                typ,
+                samples,
+                usage,
+                tiling,
+                count,
+                data,
+            );
             vk::Result::SUCCESS
         })
         // The closure always returns SUCCESS
diff --git a/src/lib.rs b/src/lib.rs
index c6ca4eb..c900fc6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,18 +1,21 @@
+#![deny(clippy::use_self)]
+#![warn(trivial_casts, trivial_numeric_casts)]
 #![allow(
     clippy::too_many_arguments,
     clippy::missing_safety_doc,
     clippy::upper_case_acronyms
 )]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 //! # Vulkan API
 //!
-//! <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/index.html>
+//! <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/index.html>
 //!
 //! ## Examples
 //!
 //! ```no_run
 //! use ash::{vk, Entry};
 //! # fn main() -> Result<(), Box<dyn std::error::Error>> {
-//! let entry = unsafe { Entry::new() }?;
+//! let entry = Entry::linked();
 //! let app_info = vk::ApplicationInfo {
 //!     api_version: vk::make_api_version(0, 1, 0, 0),
 //!     ..Default::default()
@@ -26,22 +29,25 @@
 //! ```
 //!
 //! ## Getting started
-//! Load the Vulkan library at the default location using [`Entry::new()`][EntryCustom<_>::new()],
-//! or at a custom location using [`Entry::with_library("path/to/vulkan")`][EntryCustom<_>::with_library()].
-//! These loaders use [`libloading`]. If you wish to perform function loading yourself
-//! call [`EntryCustom::new_custom()`] with a closure turning function names
-//! into function pointers.
+//!
+//! Load the Vulkan library linked at compile time using [`Entry::linked()`], or load it at runtime
+//! using [`Entry::load()`], which uses `libloading`. If you want to perform entry point loading
+//! yourself, call [`Entry::from_static_fn()`].
+//!
+//! ## Crate features
+//!
+//! * **debug** (default): Whether Vulkan structs should implement `Debug`.
+//! * **loaded** (default): Support searching for the Vulkan loader manually at runtime.
+//! * **linked**: Link the Vulkan loader at compile time.
 
 pub use crate::device::Device;
-pub use crate::entry::{EntryCustom, InstanceError};
-#[cfg(feature = "libloading")]
-pub use crate::entry_libloading::{Entry, LoadingError};
+pub use crate::entry::Entry;
+#[cfg(feature = "loaded")]
+pub use crate::entry::LoadingError;
 pub use crate::instance::Instance;
 
 mod device;
 mod entry;
-#[cfg(feature = "libloading")]
-mod entry_libloading;
 mod instance;
 pub mod prelude;
 pub mod util;
@@ -60,13 +66,113 @@ pub trait RawPtr<T> {
 impl<'r, T> RawPtr<T> for Option<&'r T> {
     fn as_raw_ptr(&self) -> *const T {
         match *self {
-            Some(inner) => inner as *const T,
-
+            Some(inner) => inner,
             _ => ::std::ptr::null(),
         }
     }
 }
 
+/// Given a mutable raw pointer to a type with an `s_type` member such as [`vk::BaseOutStructure`],
+/// match on a set of Vulkan structures. The struct will be rebound to the given variable of the
+/// type of the given Vulkan structure.
+///
+/// Note that all match bodies have to be enclosed by curly braces due to macro parsing limitations.
+/// It is unfortunately not possible to write `x @ ash::vk::SomeStruct => one_line_expression(),`.
+///
+/// ```
+/// let mut info = ash::vk::DeviceCreateInfo::default();
+/// let info: *mut ash::vk::BaseOutStructure = <*mut _>::cast(&mut info);
+/// unsafe {
+///     ash::match_out_struct!(match info {
+///         info @ ash::vk::DeviceQueueCreateInfo => {
+///             dbg!(&info); // Unreachable
+///         }
+///         info @ ash::vk::DeviceCreateInfo => {
+///             dbg!(&info);
+///         }
+///     })
+/// }
+/// ```
+///
+/// In addition this macro propagates implicit return values just like normal `match` blocks, as
+/// long as a default value or expression is provided in the "any" match arm
+/// (`_ => { some_value() }`). For the time being said arm must be wrapped in curly braces; an
+/// expression like `_ => None` is not yet supported.
+///
+/// ```
+/// # let mut info = ash::vk::DeviceCreateInfo::default();
+/// # let info: *mut ash::vk::BaseOutStructure = <*mut _>::cast(&mut info);
+/// let device_create_flags: Option<ash::vk::DeviceCreateFlags> = unsafe {
+///     ash::match_out_struct!(match info {
+///         info @ ash::vk::DeviceQueueCreateInfo => {
+///             dbg!(&info); // Unreachable
+///             Some(ash::vk::DeviceCreateFlags::empty())
+///         }
+///         info @ ash::vk::DeviceCreateInfo => {
+///             dbg!(&info);
+///             Some(info.flags)
+///         }
+///         _ => {
+///             None
+///         }
+///     })
+/// };
+/// ```
+#[macro_export]
+macro_rules! match_out_struct {
+    (match $p:ident { $($bind:ident @ $ty:path => $body:block $(,)?)+ $(_ => $any:block $(,)?)? }) => {
+        match std::ptr::addr_of!((*$p).s_type).read() {
+            $(<$ty as $crate::vk::TaggedStructure>::STRUCTURE_TYPE => {
+                let $bind = $p
+                    .cast::<$ty>()
+                    .as_mut()
+                    .unwrap();
+                $body
+            }),+
+            _ => { $($any)? }
+        }
+    };
+}
+
+/// Given an immutable raw pointer to a type with an `s_type` member such as [`vk::BaseInStructure`],
+/// match on a set of Vulkan structures. The struct will be rebound to the given variable of the
+/// type of the given Vulkan structure.
+///
+/// Note that all match bodies have to be enclosed by curly braces due to macro parsing limitations.
+/// It is unfortunately not possible to write `x @ ash::vk::SomeStruct => one_line_expression(),`.
+///
+/// ```
+/// let info = ash::vk::DeviceCreateInfo::default();
+/// let info: *const ash::vk::BaseInStructure = <*const _>::cast(&info);
+/// unsafe {
+///     ash::match_in_struct!(match info {
+///         info @ ash::vk::DeviceQueueCreateInfo => {
+///             dbg!(&info); // Unreachable
+///         }
+///         info @ ash::vk::DeviceCreateInfo => {
+///             dbg!(&info);
+///         }
+///     })
+/// }
+/// ```
+///
+/// See the [`match_out_struct!`] documentation for an example with implicit return values.
+#[macro_export]
+macro_rules! match_in_struct {
+    (match $p:ident { $($bind:ident @ $ty:path => $body:block $(,)?)+ $(_ => $any:block $(,)?)? }) => {
+        match std::ptr::addr_of!((*$p).s_type).read() {
+            $(<$ty as $crate::vk::TaggedStructure>::STRUCTURE_TYPE => {
+                let $bind = $p
+                    .cast::<$ty>()
+                    .as_ref()
+                    .unwrap();
+                $body
+            }),+
+            _ => { $($any)? }
+        }
+    };
+}
+
 #[cfg(test)]
 mod tests {
     use super::vk;
@@ -75,16 +181,15 @@ mod tests {
         let mut variable_pointers = vk::PhysicalDeviceVariablePointerFeatures::builder();
         let mut corner = vk::PhysicalDeviceCornerSampledImageFeaturesNV::builder();
         let chain = vec![
-            &variable_pointers as *const _ as usize,
-            &corner as *const _ as usize,
+            <*mut _>::cast(&mut variable_pointers),
+            <*mut _>::cast(&mut corner),
         ];
         let mut device_create_info = vk::DeviceCreateInfo::builder()
             .push_next(&mut corner)
             .push_next(&mut variable_pointers);
-        let chain2: Vec<usize> = unsafe {
+        let chain2: Vec<*mut vk::BaseOutStructure> = unsafe {
             vk::ptr_chain_iter(&mut device_create_info)
                 .skip(1)
-                .map(|ptr| ptr as usize)
                 .collect()
         };
         assert_eq!(chain, chain2);
diff --git a/src/prelude.rs b/src/prelude.rs
index 45a909a..e434803 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -1,36 +1,39 @@
 use std::convert::TryInto;
+#[cfg(feature = "debug")]
+use std::fmt;
+use std::mem;
 
 use crate::vk;
 pub type VkResult<T> = Result<T, vk::Result>;
 
-impl From<vk::Result> for VkResult<()> {
-    fn from(err_code: vk::Result) -> Self {
-        err_code.result()
-    }
-}
-
 impl vk::Result {
+    #[inline]
     pub fn result(self) -> VkResult<()> {
         self.result_with_success(())
     }
 
+    #[inline]
     pub fn result_with_success<T>(self, v: T) -> VkResult<T> {
         match self {
-            vk::Result::SUCCESS => Ok(v),
+            Self::SUCCESS => Ok(v),
             _ => Err(self),
         }
     }
+
+    #[inline]
+    pub unsafe fn assume_init_on_success<T>(self, v: mem::MaybeUninit<T>) -> VkResult<T> {
+        self.result().map(move |()| v.assume_init())
+    }
 }
 
-/// Repeatedly calls `f` until it does not return [`vk::Result::INCOMPLETE`] anymore,
-/// ensuring all available data has been read into the vector.
+/// Repeatedly calls `f` until it does not return [`vk::Result::INCOMPLETE`] anymore, ensuring all
+/// available data has been read into the vector.
 ///
-/// See for example [`vkEnumerateInstanceExtensionProperties`]: the number of available
-/// items may change between calls; [`vk::Result::INCOMPLETE`] is returned when the count
-/// increased (and the vector is not large enough after querying the initial size),
-/// requiring Ash to try again.
+/// See for example [`vkEnumerateInstanceExtensionProperties`]: the number of available items may
+/// change between calls; [`vk::Result::INCOMPLETE`] is returned when the count increased (and the
+/// vector is not large enough after querying the initial size), requiring Ash to try again.
 ///
-/// [`vkEnumerateInstanceExtensionProperties`]: https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceExtensionProperties.html
+/// [`vkEnumerateInstanceExtensionProperties`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceExtensionProperties.html
 pub(crate) unsafe fn read_into_uninitialized_vector<N: Copy + Default + TryInto<usize>, T>(
     f: impl Fn(&mut N, *mut T) -> vk::Result,
 ) -> VkResult<Vec<T>>
@@ -45,26 +48,26 @@ where
 
         let err_code = f(&mut count, data.as_mut_ptr());
         if err_code != vk::Result::INCOMPLETE {
+            err_code.result()?;
             data.set_len(count.try_into().expect("`N` failed to convert to `usize`"));
-            break err_code.result_with_success(data);
+            break Ok(data);
         }
     }
 }
 
-/// Repeatedly calls `f` until it does not return [`vk::Result::INCOMPLETE`] anymore,
-/// ensuring all available data has been read into the vector.
+/// Repeatedly calls `f` until it does not return [`vk::Result::INCOMPLETE`] anymore, ensuring all
+/// available data has been read into the vector.
 ///
-/// Items in the target vector are [`default()`][`Default::default()`]-initialized which
-/// is required for [`vk::BaseOutStructure`]-like structs where [`vk::BaseOutStructure::s_type`]
-/// needs to be a valid type and [`vk::BaseOutStructure::p_next`] a valid or
-/// [`null`][`std::ptr::null_mut()`] pointer.
+/// Items in the target vector are [`default()`][Default::default()]-initialized which is required
+/// for [`vk::BaseOutStructure`]-like structs where [`vk::BaseOutStructure::s_type`] needs to be a
+/// valid type and [`vk::BaseOutStructure::p_next`] a valid or [`null`][std::ptr::null_mut()]
+/// pointer.
 ///
-/// See for example [`vkEnumerateInstanceExtensionProperties`]: the number of available
-/// items may change between calls; [`vk::Result::INCOMPLETE`] is returned when the count
-/// increased (and the vector is not large enough after querying the initial size),
-/// requiring Ash to try again.
+/// See for example [`vkEnumerateInstanceExtensionProperties`]: the number of available items may
+/// change between calls; [`vk::Result::INCOMPLETE`] is returned when the count increased (and the
+/// vector is not large enough after querying the initial size), requiring Ash to try again.
 ///
-/// [`vkEnumerateInstanceExtensionProperties`]: https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceExtensionProperties.html
+/// [`vkEnumerateInstanceExtensionProperties`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/vkEnumerateInstanceExtensionProperties.html
 pub(crate) unsafe fn read_into_defaulted_vector<
     N: Copy + Default + TryInto<usize>,
     T: Default + Clone,
@@ -87,3 +90,31 @@ where
         }
     }
 }
+
+#[cfg(feature = "debug")]
+pub(crate) fn debug_flags<Value: Into<u64> + Copy>(
+    f: &mut fmt::Formatter,
+    known: &[(Value, &'static str)],
+    value: Value,
+) -> fmt::Result {
+    let mut first = true;
+    let mut accum = value.into();
+    for &(bit, name) in known {
+        let bit = bit.into();
+        if bit != 0 && accum & bit == bit {
+            if !first {
+                f.write_str(" | ")?;
+            }
+            f.write_str(name)?;
+            first = false;
+            accum &= !bit;
+        }
+    }
+    if accum != 0 {
+        if !first {
+            f.write_str(" | ")?;
+        }
+        write!(f, "{accum:b}")?;
+    }
+    Ok(())
+}
diff --git a/src/util.rs b/src/util.rs
index 8e27622..9827617 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -31,7 +31,7 @@ impl<T: Copy> Align<T> {
         use std::slice::from_raw_parts_mut;
         if self.elem_size == size_of::<T>() as u64 {
             unsafe {
-                let mapped_slice = from_raw_parts_mut(self.ptr as *mut T, slice.len());
+                let mapped_slice = from_raw_parts_mut(self.ptr.cast(), slice.len());
                 mapped_slice.copy_from_slice(slice);
             }
         } else {
@@ -51,7 +51,7 @@ impl<T> Align<T> {
         let padding = calc_padding(size_of::<T>() as vk::DeviceSize, alignment);
         let elem_size = size_of::<T>() as vk::DeviceSize + padding;
         assert!(calc_padding(size, alignment) == 0, "size must be aligned");
-        Align {
+        Self {
             ptr,
             elem_size,
             size,
@@ -75,7 +75,9 @@ impl<'a, T: Copy + 'a> Iterator for AlignIter<'a, T> {
         }
         unsafe {
             // Need to cast to *mut u8 because () has size 0
-            let ptr = (self.align.ptr as *mut u8).offset(self.current as isize) as *mut T;
+            let ptr = (self.align.ptr.cast::<u8>())
+                .offset(self.current as isize)
+                .cast();
             self.current += self.align.elem_size;
             Some(&mut *ptr)
         }
@@ -102,7 +104,9 @@ impl<'a, T: Copy + 'a> Iterator for AlignIter<'a, T> {
 /// let words = ash::util::read_spv(&mut std::io::Cursor::new(&SPIRV[..])).unwrap();
 /// ```
 pub fn read_spv<R: io::Read + io::Seek>(x: &mut R) -> io::Result<Vec<u32>> {
+    // TODO use stream_len() once it is stabilized and remove the subsequent rewind() call
     let size = x.seek(io::SeekFrom::End(0))?;
+    x.rewind()?;
     if size % 4 != 0 {
         return Err(io::Error::new(
             io::ErrorKind::InvalidData,
@@ -117,8 +121,9 @@ pub fn read_spv<R: io::Read + io::Seek>(x: &mut R) -> io::Result<Vec<u32>> {
     // Zero-initialize the result to prevent read_exact from possibly
     // reading uninitialized memory.
     let mut result = vec![0u32; words];
-    x.seek(io::SeekFrom::Start(0))?;
-    x.read_exact(unsafe { slice::from_raw_parts_mut(result.as_mut_ptr() as *mut u8, words * 4) })?;
+    x.read_exact(unsafe {
+        slice::from_raw_parts_mut(result.as_mut_ptr().cast::<u8>(), words * 4)
+    })?;
     const MAGIC_NUMBER: u32 = 0x0723_0203;
     if !result.is_empty() && result[0] == MAGIC_NUMBER.swap_bytes() {
         for word in &mut result {
diff --git a/src/version.rs b/src/version.rs
deleted file mode 100644
index 18dd2c9..0000000
--- a/src/version.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub use crate::device::{DeviceV1_0, DeviceV1_1, DeviceV1_2};
-pub use crate::entry::{EntryV1_0, EntryV1_1, EntryV1_2};
-pub use crate::instance::{InstanceV1_0, InstanceV1_1, InstanceV1_2};
diff --git a/src/vk.rs b/src/vk.rs
index 828b06c..02a5e9c 100644
--- a/src/vk.rs
+++ b/src/vk.rs
@@ -10,8 +10,8 @@ mod aliases;
 pub use aliases::*;
 mod bitflags;
 pub use bitflags::*;
+#[cfg(feature = "debug")]
 mod const_debugs;
-pub(crate) use const_debugs::*;
 mod constants;
 pub use constants::*;
 mod definitions;
@@ -24,21 +24,22 @@ mod feature_extensions;
 pub use feature_extensions::*;
 mod features;
 pub use features::*;
-#[doc = r" Native bindings from Vulkan headers, generated by bindgen"]
-#[allow(nonstandard_style)]
-#[allow(deref_nullptr)]
+mod prelude;
+pub use prelude::*;
+/// Native bindings from Vulkan headers, generated by bindgen
+#[allow(clippy::useless_transmute, nonstandard_style)]
 pub mod native;
 mod platform_types;
 pub use platform_types::*;
-#[doc = r" Iterates through the pointer chain. Includes the item that is passed into the function."]
-#[doc = r" Stops at the last `BaseOutStructure` that has a null `p_next` field."]
+/// Iterates through the pointer chain. Includes the item that is passed into the function.
+/// Stops at the last [`BaseOutStructure`] that has a null [`BaseOutStructure::p_next`] field.
 pub(crate) unsafe fn ptr_chain_iter<T>(ptr: &mut T) -> impl Iterator<Item = *mut BaseOutStructure> {
-    let ptr: *mut BaseOutStructure = ptr as *mut T as _;
+    let ptr = <*mut T>::cast::<BaseOutStructure>(ptr);
     (0..).scan(ptr, |p_ptr, _| {
         if p_ptr.is_null() {
             return None;
         }
-        let n_ptr = (**p_ptr).p_next as *mut BaseOutStructure;
+        let n_ptr = (**p_ptr).p_next;
         let old = *p_ptr;
         *p_ptr = n_ptr;
         Some(old)
diff --git a/src/vk/aliases.rs b/src/vk/aliases.rs
index be39302..7eb57b7 100644
--- a/src/vk/aliases.rs
+++ b/src/vk/aliases.rs
@@ -4,8 +4,14 @@ use crate::vk::enums::*;
 pub type GeometryFlagsNV = GeometryFlagsKHR;
 pub type GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR;
 pub type BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR;
+pub type PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags;
 pub type DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags;
+pub type PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags;
 pub type SemaphoreWaitFlagsKHR = SemaphoreWaitFlags;
+pub type AccessFlags2KHR = AccessFlags2;
+pub type PipelineStageFlags2KHR = PipelineStageFlags2;
+pub type FormatFeatureFlags2KHR = FormatFeatureFlags2;
+pub type RenderingFlagsKHR = RenderingFlags;
 pub type PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags;
 pub type MemoryAllocateFlagsKHR = MemoryAllocateFlags;
 pub type CommandPoolTrimFlagsKHR = CommandPoolTrimFlags;
@@ -19,10 +25,14 @@ pub type ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags;
 pub type FenceImportFlagsKHR = FenceImportFlags;
 pub type DescriptorBindingFlagsEXT = DescriptorBindingFlags;
 pub type ResolveModeFlagsKHR = ResolveModeFlags;
+pub type ToolPurposeFlagsEXT = ToolPurposeFlags;
+pub type SubmitFlagsKHR = SubmitFlags;
 pub type DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
 pub type SamplerYcbcrConversionKHR = SamplerYcbcrConversion;
+pub type PrivateDataSlotEXT = PrivateDataSlot;
 pub type DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType;
 pub type PointClippingBehaviorKHR = PointClippingBehavior;
+pub type QueueGlobalPriorityEXT = QueueGlobalPriorityKHR;
 pub type SemaphoreTypeKHR = SemaphoreType;
 pub type CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR;
 pub type AccelerationStructureTypeNV = AccelerationStructureTypeKHR;
@@ -35,6 +45,9 @@ pub type ChromaLocationKHR = ChromaLocation;
 pub type SamplerReductionModeEXT = SamplerReductionMode;
 pub type ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence;
 pub type DriverIdKHR = DriverId;
+pub type DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo;
+pub type PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo;
+pub type PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures;
 pub type PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2;
 pub type PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2;
 pub type FormatProperties2KHR = FormatProperties2;
@@ -86,8 +99,10 @@ pub type PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatu
 pub type PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR =
     PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
 pub type BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2;
+pub type DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements;
 pub type ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2;
 pub type ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2;
+pub type DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements;
 pub type MemoryRequirements2KHR = MemoryRequirements2;
 pub type SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2;
 pub type PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties;
@@ -107,14 +122,24 @@ pub type SamplerYcbcrConversionImageFormatPropertiesKHR =
 pub type PhysicalDeviceSamplerFilterMinmaxPropertiesEXT =
     PhysicalDeviceSamplerFilterMinmaxProperties;
 pub type SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo;
+pub type PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures;
+pub type PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties;
+pub type WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock;
+pub type DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo;
 pub type ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo;
 pub type PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties;
+pub type PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features;
+pub type PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties;
 pub type DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport;
 pub type PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures;
 pub type PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
 pub type PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features;
 pub type PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties;
 pub type PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures;
+pub type DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfoKHR;
+pub type PhysicalDeviceGlobalPriorityQueryFeaturesEXT =
+    PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
+pub type QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityPropertiesKHR;
 pub type PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures;
 pub type PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties;
 pub type DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo;
@@ -141,6 +166,8 @@ pub type PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomic
 pub type PhysicalDeviceDepthStencilResolvePropertiesKHR =
     PhysicalDeviceDepthStencilResolveProperties;
 pub type SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve;
+pub type PhysicalDeviceFragmentShaderBarycentricFeaturesNV =
+    PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
 pub type ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo;
 pub type PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures;
 pub type PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR =
@@ -154,13 +181,73 @@ pub type PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImageless
 pub type FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo;
 pub type FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo;
 pub type RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo;
+pub type PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT =
+    PhysicalDeviceTextureCompressionASTCHDRFeatures;
+pub type PipelineCreationFeedbackEXT = PipelineCreationFeedback;
+pub type PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo;
 pub type QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL;
 pub type PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR =
     PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
 pub type AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout;
 pub type AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout;
+pub type PipelineInfoEXT = PipelineInfoKHR;
+pub type PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT =
+    PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
+pub type PhysicalDeviceTexelBufferAlignmentPropertiesEXT =
+    PhysicalDeviceTexelBufferAlignmentProperties;
+pub type PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures;
+pub type PhysicalDeviceSubgroupSizeControlPropertiesEXT =
+    PhysicalDeviceSubgroupSizeControlProperties;
+pub type PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT =
+    PipelineShaderStageRequiredSubgroupSizeCreateInfo;
+pub type ShaderRequiredSubgroupSizeCreateInfoEXT =
+    PipelineShaderStageRequiredSubgroupSizeCreateInfo;
 pub type MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo;
 pub type DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo;
+pub type PhysicalDevicePipelineCreationCacheControlFeaturesEXT =
+    PhysicalDevicePipelineCreationCacheControlFeatures;
+pub type PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties;
 pub type AabbPositionsNV = AabbPositionsKHR;
 pub type TransformMatrixNV = TransformMatrixKHR;
 pub type AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR;
+pub type PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR =
+    PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
+pub type PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures;
+pub type BufferCopy2KHR = BufferCopy2;
+pub type ImageCopy2KHR = ImageCopy2;
+pub type ImageBlit2KHR = ImageBlit2;
+pub type BufferImageCopy2KHR = BufferImageCopy2;
+pub type ImageResolve2KHR = ImageResolve2;
+pub type CopyBufferInfo2KHR = CopyBufferInfo2;
+pub type CopyImageInfo2KHR = CopyImageInfo2;
+pub type BlitImageInfo2KHR = BlitImageInfo2;
+pub type CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2;
+pub type CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2;
+pub type ResolveImageInfo2KHR = ResolveImageInfo2;
+pub type PhysicalDeviceShaderTerminateInvocationFeaturesKHR =
+    PhysicalDeviceShaderTerminateInvocationFeatures;
+pub type PhysicalDeviceMutableDescriptorTypeFeaturesVALVE =
+    PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
+pub type MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT;
+pub type MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT;
+pub type MemoryBarrier2KHR = MemoryBarrier2;
+pub type ImageMemoryBarrier2KHR = ImageMemoryBarrier2;
+pub type BufferMemoryBarrier2KHR = BufferMemoryBarrier2;
+pub type DependencyInfoKHR = DependencyInfo;
+pub type SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo;
+pub type CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo;
+pub type SubmitInfo2KHR = SubmitInfo2;
+pub type PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features;
+pub type PhysicalDeviceShaderIntegerDotProductFeaturesKHR =
+    PhysicalDeviceShaderIntegerDotProductFeatures;
+pub type PhysicalDeviceShaderIntegerDotProductPropertiesKHR =
+    PhysicalDeviceShaderIntegerDotProductProperties;
+pub type FormatProperties3KHR = FormatProperties3;
+pub type PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo;
+pub type RenderingInfoKHR = RenderingInfo;
+pub type RenderingAttachmentInfoKHR = RenderingAttachmentInfo;
+pub type PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures;
+pub type CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo;
+pub type AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD;
+pub type PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM =
+    PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
diff --git a/src/vk/bitflags.rs b/src/vk/bitflags.rs
index ee8737f..b3a5af9 100644
--- a/src/vk/bitflags.rs
+++ b/src/vk/bitflags.rs
@@ -1,15 +1,15 @@
 use crate::vk::definitions::*;
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheCreateFlagBits.html>"]
 pub struct PipelineCacheCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineCacheCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineCacheCreateFlags, Flags);
 impl PipelineCacheCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFlagBits.html>"]
 pub struct QueueFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(QueueFlags, 0b1111, Flags);
+vk_bitflags_wrapped!(QueueFlags, Flags);
 impl QueueFlags {
     #[doc = "Queue supports graphics operations"]
     pub const GRAPHICS: Self = Self(0b1);
@@ -22,9 +22,9 @@ impl QueueFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCullModeFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCullModeFlagBits.html>"]
 pub struct CullModeFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(CullModeFlags, 0b11, Flags);
+vk_bitflags_wrapped!(CullModeFlags, Flags);
 impl CullModeFlags {
     pub const NONE: Self = Self(0);
     pub const FRONT: Self = Self(0b1);
@@ -33,21 +33,21 @@ impl CullModeFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateFlagBits.html>"]
 pub struct RenderPassCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(RenderPassCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(RenderPassCreateFlags, Flags);
 impl RenderPassCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueCreateFlagBits.html>"]
 pub struct DeviceQueueCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(DeviceQueueCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(DeviceQueueCreateFlags, Flags);
 impl DeviceQueueCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryPropertyFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryPropertyFlagBits.html>"]
 pub struct MemoryPropertyFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(MemoryPropertyFlags, 0b1_1111, Flags);
+vk_bitflags_wrapped!(MemoryPropertyFlags, Flags);
 impl MemoryPropertyFlags {
     #[doc = "If otherwise stated, then allocate memory on device"]
     pub const DEVICE_LOCAL: Self = Self(0b1);
@@ -62,18 +62,18 @@ impl MemoryPropertyFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHeapFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHeapFlagBits.html>"]
 pub struct MemoryHeapFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(MemoryHeapFlags, 0b1, Flags);
+vk_bitflags_wrapped!(MemoryHeapFlags, Flags);
 impl MemoryHeapFlags {
     #[doc = "If set, heap represents device memory"]
     pub const DEVICE_LOCAL: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccessFlagBits.html>"]
 pub struct AccessFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(AccessFlags, 0b1_1111_1111_1111_1111, Flags);
+vk_bitflags_wrapped!(AccessFlags, Flags);
 impl AccessFlags {
     #[doc = "Controls coherency of indirect command reads"]
     pub const INDIRECT_COMMAND_READ: Self = Self(0b1);
@@ -112,9 +112,9 @@ impl AccessFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferUsageFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferUsageFlagBits.html>"]
 pub struct BufferUsageFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(BufferUsageFlags, 0b1_1111_1111, Flags);
+vk_bitflags_wrapped!(BufferUsageFlags, Flags);
 impl BufferUsageFlags {
     #[doc = "Can be used as a source of transfer operations"]
     pub const TRANSFER_SRC: Self = Self(0b1);
@@ -137,9 +137,9 @@ impl BufferUsageFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCreateFlagBits.html>"]
 pub struct BufferCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(BufferCreateFlags, 0b111, Flags);
+vk_bitflags_wrapped!(BufferCreateFlags, Flags);
 impl BufferCreateFlags {
     #[doc = "Buffer should support sparse backing"]
     pub const SPARSE_BINDING: Self = Self(0b1);
@@ -150,13 +150,9 @@ impl BufferCreateFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStageFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderStageFlagBits.html>"]
 pub struct ShaderStageFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(
-    ShaderStageFlags,
-    0b111_1111_1111_1111_1111_1111_1111_1111,
-    Flags
-);
+vk_bitflags_wrapped!(ShaderStageFlags, Flags);
 impl ShaderStageFlags {
     pub const VERTEX: Self = Self(0b1);
     pub const TESSELLATION_CONTROL: Self = Self(0b10);
@@ -169,9 +165,9 @@ impl ShaderStageFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageUsageFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageUsageFlagBits.html>"]
 pub struct ImageUsageFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ImageUsageFlags, 0b1111_1111, Flags);
+vk_bitflags_wrapped!(ImageUsageFlags, Flags);
 impl ImageUsageFlags {
     #[doc = "Can be used as a source of transfer operations"]
     pub const TRANSFER_SRC: Self = Self(0b1);
@@ -192,9 +188,9 @@ impl ImageUsageFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCreateFlagBits.html>"]
 pub struct ImageCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ImageCreateFlags, 0b1_1111, Flags);
+vk_bitflags_wrapped!(ImageCreateFlags, Flags);
 impl ImageCreateFlags {
     #[doc = "Image should support sparse backing"]
     pub const SPARSE_BINDING: Self = Self(0b1);
@@ -209,21 +205,21 @@ impl ImageCreateFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateFlagBits.html>"]
 pub struct ImageViewCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ImageViewCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(ImageViewCreateFlags, Flags);
 impl ImageViewCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateFlagBits.html>"]
 pub struct SamplerCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(SamplerCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(SamplerCreateFlags, Flags);
 impl SamplerCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreateFlagBits.html>"]
 pub struct PipelineCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineCreateFlags, 0b111, Flags);
+vk_bitflags_wrapped!(PipelineCreateFlags, Flags);
 impl PipelineCreateFlags {
     pub const DISABLE_OPTIMIZATION: Self = Self(0b1);
     pub const ALLOW_DERIVATIVES: Self = Self(0b10);
@@ -231,15 +227,15 @@ impl PipelineCreateFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateFlagBits.html>"]
 pub struct PipelineShaderStageCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineShaderStageCreateFlags, Flags);
 impl PipelineShaderStageCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkColorComponentFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorComponentFlagBits.html>"]
 pub struct ColorComponentFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ColorComponentFlags, 0b1111, Flags);
+vk_bitflags_wrapped!(ColorComponentFlags, Flags);
 impl ColorComponentFlags {
     pub const R: Self = Self(0b1);
     pub const G: Self = Self(0b10);
@@ -248,23 +244,23 @@ impl ColorComponentFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceCreateFlagBits.html>"]
 pub struct FenceCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(FenceCreateFlags, 0b1, Flags);
+vk_bitflags_wrapped!(FenceCreateFlags, Flags);
 impl FenceCreateFlags {
     pub const SIGNALED: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreCreateFlagBits.html>"]
 pub struct SemaphoreCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(SemaphoreCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(SemaphoreCreateFlags, Flags);
 impl SemaphoreCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatFeatureFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatFeatureFlagBits.html>"]
 pub struct FormatFeatureFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(FormatFeatureFlags, 0b1_1111_1111_1111, Flags);
+vk_bitflags_wrapped!(FormatFeatureFlags, Flags);
 impl FormatFeatureFlags {
     #[doc = "Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)"]
     pub const SAMPLED_IMAGE: Self = Self(0b1);
@@ -295,18 +291,18 @@ impl FormatFeatureFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryControlFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryControlFlagBits.html>"]
 pub struct QueryControlFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(QueryControlFlags, 0b1, Flags);
+vk_bitflags_wrapped!(QueryControlFlags, Flags);
 impl QueryControlFlags {
     #[doc = "Require precise results to be collected by the query"]
     pub const PRECISE: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryResultFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryResultFlagBits.html>"]
 pub struct QueryResultFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(QueryResultFlags, 0b1111, Flags);
+vk_bitflags_wrapped!(QueryResultFlags, Flags);
 impl QueryResultFlags {
     #[doc = "Results of the queries are written to the destination buffer as 64-bit values"]
     pub const TYPE_64: Self = Self(0b1);
@@ -319,9 +315,9 @@ impl QueryResultFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferUsageFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferUsageFlagBits.html>"]
 pub struct CommandBufferUsageFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(CommandBufferUsageFlags, 0b111, Flags);
+vk_bitflags_wrapped!(CommandBufferUsageFlags, Flags);
 impl CommandBufferUsageFlags {
     pub const ONE_TIME_SUBMIT: Self = Self(0b1);
     pub const RENDER_PASS_CONTINUE: Self = Self(0b10);
@@ -330,9 +326,9 @@ impl CommandBufferUsageFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPipelineStatisticFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPipelineStatisticFlagBits.html>"]
 pub struct QueryPipelineStatisticFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(QueryPipelineStatisticFlags, 0b111_1111_1111, Flags);
+vk_bitflags_wrapped!(QueryPipelineStatisticFlags, Flags);
 impl QueryPipelineStatisticFlags {
     #[doc = "Optional"]
     pub const INPUT_ASSEMBLY_VERTICES: Self = Self(0b1);
@@ -359,9 +355,9 @@ impl QueryPipelineStatisticFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageAspectFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageAspectFlagBits.html>"]
 pub struct ImageAspectFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ImageAspectFlags, 0b1111, Flags);
+vk_bitflags_wrapped!(ImageAspectFlags, Flags);
 impl ImageAspectFlags {
     pub const COLOR: Self = Self(0b1);
     pub const DEPTH: Self = Self(0b10);
@@ -370,9 +366,9 @@ impl ImageAspectFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatFlagBits.html>"]
 pub struct SparseImageFormatFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(SparseImageFormatFlags, 0b111, Flags);
+vk_bitflags_wrapped!(SparseImageFormatFlags, Flags);
 impl SparseImageFormatFlags {
     #[doc = "Image uses a single mip tail region for all array layers"]
     pub const SINGLE_MIPTAIL: Self = Self(0b1);
@@ -383,18 +379,18 @@ impl SparseImageFormatFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBindFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseMemoryBindFlagBits.html>"]
 pub struct SparseMemoryBindFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(SparseMemoryBindFlags, 0b1, Flags);
+vk_bitflags_wrapped!(SparseMemoryBindFlags, Flags);
 impl SparseMemoryBindFlags {
     #[doc = "Operation binds resource metadata to memory"]
     pub const METADATA: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineStageFlagBits.html>"]
 pub struct PipelineStageFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineStageFlags, 0b1_1111_1111_1111_1111, Flags);
+vk_bitflags_wrapped!(PipelineStageFlags, Flags);
 impl PipelineStageFlags {
     #[doc = "Before subsequent commands are processed"]
     pub const TOP_OF_PIPE: Self = Self(0b1);
@@ -433,9 +429,9 @@ impl PipelineStageFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolCreateFlagBits.html>"]
 pub struct CommandPoolCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(CommandPoolCreateFlags, 0b11, Flags);
+vk_bitflags_wrapped!(CommandPoolCreateFlags, Flags);
 impl CommandPoolCreateFlags {
     #[doc = "Command buffers have a short lifetime"]
     pub const TRANSIENT: Self = Self(0b1);
@@ -444,27 +440,27 @@ impl CommandPoolCreateFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolResetFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolResetFlagBits.html>"]
 pub struct CommandPoolResetFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(CommandPoolResetFlags, 0b1, Flags);
+vk_bitflags_wrapped!(CommandPoolResetFlags, Flags);
 impl CommandPoolResetFlags {
     #[doc = "Release resources owned by the pool"]
     pub const RELEASE_RESOURCES: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferResetFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferResetFlagBits.html>"]
 pub struct CommandBufferResetFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(CommandBufferResetFlags, 0b1, Flags);
+vk_bitflags_wrapped!(CommandBufferResetFlags, Flags);
 impl CommandBufferResetFlags {
     #[doc = "Release resources owned by the buffer"]
     pub const RELEASE_RESOURCES: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleCountFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleCountFlagBits.html>"]
 pub struct SampleCountFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(SampleCountFlags, 0b111_1111, Flags);
+vk_bitflags_wrapped!(SampleCountFlags, Flags);
 impl SampleCountFlags {
     #[doc = "Sample count 1 supported"]
     pub const TYPE_1: Self = Self(0b1);
@@ -483,18 +479,18 @@ impl SampleCountFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionFlagBits.html>"]
 pub struct AttachmentDescriptionFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(AttachmentDescriptionFlags, 0b1, Flags);
+vk_bitflags_wrapped!(AttachmentDescriptionFlags, Flags);
 impl AttachmentDescriptionFlags {
     #[doc = "The attachment may alias physical memory of another attachment in the same render pass"]
     pub const MAY_ALIAS: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilFaceFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilFaceFlagBits.html>"]
 pub struct StencilFaceFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(StencilFaceFlags, 0b11, Flags);
+vk_bitflags_wrapped!(StencilFaceFlags, Flags);
 impl StencilFaceFlags {
     #[doc = "Front face"]
     pub const FRONT: Self = Self(0b1);
@@ -502,40 +498,38 @@ impl StencilFaceFlags {
     pub const BACK: Self = Self(0b10);
     #[doc = "Front and back faces"]
     pub const FRONT_AND_BACK: Self = Self(0x0000_0003);
-    #[deprecated = "Alias for backwards compatibility"]
-    pub const STENCIL_FRONT_AND_BACK: Self = Self::FRONT_AND_BACK;
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolCreateFlagBits.html>"]
 pub struct DescriptorPoolCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(DescriptorPoolCreateFlags, 0b1, Flags);
+vk_bitflags_wrapped!(DescriptorPoolCreateFlags, Flags);
 impl DescriptorPoolCreateFlags {
     #[doc = "Descriptor sets may be freed individually"]
     pub const FREE_DESCRIPTOR_SET: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDependencyFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyFlagBits.html>"]
 pub struct DependencyFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(DependencyFlags, 0b1, Flags);
+vk_bitflags_wrapped!(DependencyFlags, Flags);
 impl DependencyFlags {
     #[doc = "Dependency is per pixel region "]
     pub const BY_REGION: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitFlagBits.html>"]
 pub struct SemaphoreWaitFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(SemaphoreWaitFlags, 0b1, Flags);
+vk_bitflags_wrapped!(SemaphoreWaitFlags, Flags);
 impl SemaphoreWaitFlags {
     pub const ANY: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html>"]
 pub struct DisplayPlaneAlphaFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, 0b1111, Flags);
+vk_bitflags_wrapped!(DisplayPlaneAlphaFlagsKHR, Flags);
 impl DisplayPlaneAlphaFlagsKHR {
     pub const OPAQUE: Self = Self(0b1);
     pub const GLOBAL: Self = Self(0b10);
@@ -544,9 +538,9 @@ impl DisplayPlaneAlphaFlagsKHR {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCompositeAlphaFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCompositeAlphaFlagBitsKHR.html>"]
 pub struct CompositeAlphaFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, 0b1111, Flags);
+vk_bitflags_wrapped!(CompositeAlphaFlagsKHR, Flags);
 impl CompositeAlphaFlagsKHR {
     pub const OPAQUE: Self = Self(0b1);
     pub const PRE_MULTIPLIED: Self = Self(0b10);
@@ -555,9 +549,9 @@ impl CompositeAlphaFlagsKHR {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceTransformFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceTransformFlagBitsKHR.html>"]
 pub struct SurfaceTransformFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, 0b1_1111_1111, Flags);
+vk_bitflags_wrapped!(SurfaceTransformFlagsKHR, Flags);
 impl SurfaceTransformFlagsKHR {
     pub const IDENTITY: Self = Self(0b1);
     pub const ROTATE_90: Self = Self(0b10);
@@ -571,17 +565,17 @@ impl SurfaceTransformFlagsKHR {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageUsageFlagBitsANDROID.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainImageUsageFlagBitsANDROID.html>"]
 pub struct SwapchainImageUsageFlagsANDROID(pub(crate) Flags);
-vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, 0b1, Flags);
+vk_bitflags_wrapped!(SwapchainImageUsageFlagsANDROID, Flags);
 impl SwapchainImageUsageFlagsANDROID {
     pub const SHARED: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportFlagBitsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportFlagBitsEXT.html>"]
 pub struct DebugReportFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(DebugReportFlagsEXT, 0b1_1111, Flags);
+vk_bitflags_wrapped!(DebugReportFlagsEXT, Flags);
 impl DebugReportFlagsEXT {
     pub const INFORMATION: Self = Self(0b1);
     pub const WARNING: Self = Self(0b10);
@@ -591,9 +585,9 @@ impl DebugReportFlagsEXT {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html>"]
 pub struct ExternalMemoryHandleTypeFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, 0b1111, Flags);
+vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlagsNV, Flags);
 impl ExternalMemoryHandleTypeFlagsNV {
     pub const OPAQUE_WIN32: Self = Self(0b1);
     pub const OPAQUE_WIN32_KMT: Self = Self(0b10);
@@ -602,9 +596,9 @@ impl ExternalMemoryHandleTypeFlagsNV {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBitsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryFeatureFlagBitsNV.html>"]
 pub struct ExternalMemoryFeatureFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, 0b111, Flags);
+vk_bitflags_wrapped!(ExternalMemoryFeatureFlagsNV, Flags);
 impl ExternalMemoryFeatureFlagsNV {
     pub const DEDICATED_ONLY: Self = Self(0b1);
     pub const EXPORTABLE: Self = Self(0b10);
@@ -612,9 +606,9 @@ impl ExternalMemoryFeatureFlagsNV {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubgroupFeatureFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubgroupFeatureFlagBits.html>"]
 pub struct SubgroupFeatureFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(SubgroupFeatureFlags, 0b1111_1111, Flags);
+vk_bitflags_wrapped!(SubgroupFeatureFlags, Flags);
 impl SubgroupFeatureFlags {
     #[doc = "Basic subgroup operations"]
     pub const BASIC: Self = Self(0b1);
@@ -635,9 +629,9 @@ impl SubgroupFeatureFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html>"]
 pub struct IndirectCommandsLayoutUsageFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, 0b111, Flags);
+vk_bitflags_wrapped!(IndirectCommandsLayoutUsageFlagsNV, Flags);
 impl IndirectCommandsLayoutUsageFlagsNV {
     pub const EXPLICIT_PREPROCESS: Self = Self(0b1);
     pub const INDEXED_SEQUENCES: Self = Self(0b10);
@@ -645,29 +639,29 @@ impl IndirectCommandsLayoutUsageFlagsNV {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectStateFlagBitsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectStateFlagBitsNV.html>"]
 pub struct IndirectStateFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(IndirectStateFlagsNV, 0b1, Flags);
+vk_bitflags_wrapped!(IndirectStateFlagsNV, Flags);
 impl IndirectStateFlagsNV {
     pub const FLAG_FRONTFACE: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPrivateDataSlotCreateFlagBitsEXT.html>"]
-pub struct PrivateDataSlotCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(PrivateDataSlotCreateFlagsEXT, 0b0, Flags);
-impl PrivateDataSlotCreateFlagsEXT {}
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateFlagBits.html>"]
+pub struct PrivateDataSlotCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(PrivateDataSlotCreateFlags, Flags);
+impl PrivateDataSlotCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutCreateFlagBits.html>"]
 pub struct DescriptorSetLayoutCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(DescriptorSetLayoutCreateFlags, Flags);
 impl DescriptorSetLayoutCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryHandleTypeFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryHandleTypeFlagBits.html>"]
 pub struct ExternalMemoryHandleTypeFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, 0b111_1111, Flags);
+vk_bitflags_wrapped!(ExternalMemoryHandleTypeFlags, Flags);
 impl ExternalMemoryHandleTypeFlags {
     pub const OPAQUE_FD: Self = Self(0b1);
     pub const OPAQUE_WIN32: Self = Self(0b10);
@@ -679,9 +673,9 @@ impl ExternalMemoryHandleTypeFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryFeatureFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryFeatureFlagBits.html>"]
 pub struct ExternalMemoryFeatureFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, 0b111, Flags);
+vk_bitflags_wrapped!(ExternalMemoryFeatureFlags, Flags);
 impl ExternalMemoryFeatureFlags {
     pub const DEDICATED_ONLY: Self = Self(0b1);
     pub const EXPORTABLE: Self = Self(0b10);
@@ -689,9 +683,9 @@ impl ExternalMemoryFeatureFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreHandleTypeFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreHandleTypeFlagBits.html>"]
 pub struct ExternalSemaphoreHandleTypeFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, 0b1_1111, Flags);
+vk_bitflags_wrapped!(ExternalSemaphoreHandleTypeFlags, Flags);
 impl ExternalSemaphoreHandleTypeFlags {
     pub const OPAQUE_FD: Self = Self(0b1);
     pub const OPAQUE_WIN32: Self = Self(0b10);
@@ -702,26 +696,26 @@ impl ExternalSemaphoreHandleTypeFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreFeatureFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreFeatureFlagBits.html>"]
 pub struct ExternalSemaphoreFeatureFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, 0b11, Flags);
+vk_bitflags_wrapped!(ExternalSemaphoreFeatureFlags, Flags);
 impl ExternalSemaphoreFeatureFlags {
     pub const EXPORTABLE: Self = Self(0b1);
     pub const IMPORTABLE: Self = Self(0b10);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreImportFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreImportFlagBits.html>"]
 pub struct SemaphoreImportFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(SemaphoreImportFlags, 0b1, Flags);
+vk_bitflags_wrapped!(SemaphoreImportFlags, Flags);
 impl SemaphoreImportFlags {
     pub const TEMPORARY: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceHandleTypeFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceHandleTypeFlagBits.html>"]
 pub struct ExternalFenceHandleTypeFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, 0b1111, Flags);
+vk_bitflags_wrapped!(ExternalFenceHandleTypeFlags, Flags);
 impl ExternalFenceHandleTypeFlags {
     pub const OPAQUE_FD: Self = Self(0b1);
     pub const OPAQUE_WIN32: Self = Self(0b10);
@@ -730,34 +724,34 @@ impl ExternalFenceHandleTypeFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceFeatureFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceFeatureFlagBits.html>"]
 pub struct ExternalFenceFeatureFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ExternalFenceFeatureFlags, 0b11, Flags);
+vk_bitflags_wrapped!(ExternalFenceFeatureFlags, Flags);
 impl ExternalFenceFeatureFlags {
     pub const EXPORTABLE: Self = Self(0b1);
     pub const IMPORTABLE: Self = Self(0b10);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceImportFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceImportFlagBits.html>"]
 pub struct FenceImportFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(FenceImportFlags, 0b1, Flags);
+vk_bitflags_wrapped!(FenceImportFlags, Flags);
 impl FenceImportFlags {
     pub const TEMPORARY: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCounterFlagBitsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCounterFlagBitsEXT.html>"]
 pub struct SurfaceCounterFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, 0b1, Flags);
+vk_bitflags_wrapped!(SurfaceCounterFlagsEXT, Flags);
 impl SurfaceCounterFlagsEXT {
     pub const VBLANK: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPeerMemoryFeatureFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPeerMemoryFeatureFlagBits.html>"]
 pub struct PeerMemoryFeatureFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PeerMemoryFeatureFlags, 0b1111, Flags);
+vk_bitflags_wrapped!(PeerMemoryFeatureFlags, Flags);
 impl PeerMemoryFeatureFlags {
     #[doc = "Can read with vkCmdCopy commands"]
     pub const COPY_SRC: Self = Self(0b1);
@@ -770,18 +764,18 @@ impl PeerMemoryFeatureFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlagBits.html>"]
 pub struct MemoryAllocateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(MemoryAllocateFlags, 0b1, Flags);
+vk_bitflags_wrapped!(MemoryAllocateFlags, Flags);
 impl MemoryAllocateFlags {
     #[doc = "Force allocation on specific devices"]
     pub const DEVICE_MASK: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html>"]
 pub struct DeviceGroupPresentModeFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, 0b1111, Flags);
+vk_bitflags_wrapped!(DeviceGroupPresentModeFlagsKHR, Flags);
 impl DeviceGroupPresentModeFlagsKHR {
     #[doc = "Present from local memory"]
     pub const LOCAL: Self = Self(0b1);
@@ -794,21 +788,21 @@ impl DeviceGroupPresentModeFlagsKHR {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCreateFlagBitsKHR.html>"]
 pub struct SwapchainCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(SwapchainCreateFlagsKHR, Flags);
 impl SwapchainCreateFlagsKHR {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionFlagBits.html>"]
 pub struct SubpassDescriptionFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(SubpassDescriptionFlags, 0b0, Flags);
+vk_bitflags_wrapped!(SubpassDescriptionFlags, Flags);
 impl SubpassDescriptionFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html>"]
 pub struct DebugUtilsMessageSeverityFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, 0b1_0001_0001_0001, Flags);
+vk_bitflags_wrapped!(DebugUtilsMessageSeverityFlagsEXT, Flags);
 impl DebugUtilsMessageSeverityFlagsEXT {
     pub const VERBOSE: Self = Self(0b1);
     pub const INFO: Self = Self(0b1_0000);
@@ -817,9 +811,9 @@ impl DebugUtilsMessageSeverityFlagsEXT {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html>"]
 pub struct DebugUtilsMessageTypeFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, 0b111, Flags);
+vk_bitflags_wrapped!(DebugUtilsMessageTypeFlagsEXT, Flags);
 impl DebugUtilsMessageTypeFlagsEXT {
     pub const GENERAL: Self = Self(0b1);
     pub const VALIDATION: Self = Self(0b10);
@@ -827,9 +821,9 @@ impl DebugUtilsMessageTypeFlagsEXT {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBindingFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBindingFlagBits.html>"]
 pub struct DescriptorBindingFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(DescriptorBindingFlags, 0b1111, Flags);
+vk_bitflags_wrapped!(DescriptorBindingFlags, Flags);
 impl DescriptorBindingFlags {
     pub const UPDATE_AFTER_BIND: Self = Self(0b1);
     pub const UPDATE_UNUSED_WHILE_PENDING: Self = Self(0b10);
@@ -838,17 +832,17 @@ impl DescriptorBindingFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingFlagBitsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConditionalRenderingFlagBitsEXT.html>"]
 pub struct ConditionalRenderingFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, 0b1, Flags);
+vk_bitflags_wrapped!(ConditionalRenderingFlagsEXT, Flags);
 impl ConditionalRenderingFlagsEXT {
     pub const INVERTED: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResolveModeFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveModeFlagBits.html>"]
 pub struct ResolveModeFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ResolveModeFlags, 0b1111, Flags);
+vk_bitflags_wrapped!(ResolveModeFlags, Flags);
 impl ResolveModeFlags {
     pub const NONE: Self = Self(0);
     pub const SAMPLE_ZERO: Self = Self(0b1);
@@ -858,9 +852,9 @@ impl ResolveModeFlags {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryInstanceFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryInstanceFlagBitsKHR.html>"]
 pub struct GeometryInstanceFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, 0b1111, Flags);
+vk_bitflags_wrapped!(GeometryInstanceFlagsKHR, Flags);
 impl GeometryInstanceFlagsKHR {
     pub const TRIANGLE_FACING_CULL_DISABLE: Self = Self(0b1);
     pub const TRIANGLE_FLIP_FACING: Self = Self(0b10);
@@ -870,18 +864,18 @@ impl GeometryInstanceFlagsKHR {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryFlagBitsKHR.html>"]
 pub struct GeometryFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(GeometryFlagsKHR, 0b11, Flags);
+vk_bitflags_wrapped!(GeometryFlagsKHR, Flags);
 impl GeometryFlagsKHR {
     pub const OPAQUE: Self = Self(0b1);
     pub const NO_DUPLICATE_ANY_HIT_INVOCATION: Self = Self(0b10);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuildAccelerationStructureFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuildAccelerationStructureFlagBitsKHR.html>"]
 pub struct BuildAccelerationStructureFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, 0b1_1111, Flags);
+vk_bitflags_wrapped!(BuildAccelerationStructureFlagsKHR, Flags);
 impl BuildAccelerationStructureFlagsKHR {
     pub const ALLOW_UPDATE: Self = Self(0b1);
     pub const ALLOW_COMPACTION: Self = Self(0b10);
@@ -891,187 +885,295 @@ impl BuildAccelerationStructureFlagsKHR {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateFlagBitsKHR.html>"]
 pub struct AccelerationStructureCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, 0b1, Flags);
+vk_bitflags_wrapped!(AccelerationStructureCreateFlagsKHR, Flags);
 impl AccelerationStructureCreateFlagsKHR {
     pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferCreateFlagBits.html>"]
 pub struct FramebufferCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(FramebufferCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(FramebufferCreateFlags, Flags);
 impl FramebufferCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html>"]
 pub struct DeviceDiagnosticsConfigFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, 0b111, Flags);
+vk_bitflags_wrapped!(DeviceDiagnosticsConfigFlagsNV, Flags);
 impl DeviceDiagnosticsConfigFlagsNV {
     pub const ENABLE_SHADER_DEBUG_INFO: Self = Self(0b1);
     pub const ENABLE_RESOURCE_TRACKING: Self = Self(0b10);
     pub const ENABLE_AUTOMATIC_CHECKPOINTS: Self = Self(0b100);
+    pub const ENABLE_SHADER_ERROR_REPORTING: Self = Self(0b1000);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackFlagBitsEXT.html>"]
-pub struct PipelineCreationFeedbackFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineCreationFeedbackFlagsEXT, 0b111, Flags);
-impl PipelineCreationFeedbackFlagsEXT {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackFlagBits.html>"]
+pub struct PipelineCreationFeedbackFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(PipelineCreationFeedbackFlags, Flags);
+impl PipelineCreationFeedbackFlags {
     pub const VALID: Self = Self(0b1);
+    pub const VALID_EXT: Self = Self::VALID;
     pub const APPLICATION_PIPELINE_CACHE_HIT: Self = Self(0b10);
+    pub const APPLICATION_PIPELINE_CACHE_HIT_EXT: Self = Self::APPLICATION_PIPELINE_CACHE_HIT;
     pub const BASE_PIPELINE_ACCELERATION: Self = Self(0b100);
+    pub const BASE_PIPELINE_ACCELERATION_EXT: Self = Self::BASE_PIPELINE_ACCELERATION;
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDecompressionMethodFlagBitsNV.html>"]
+pub struct MemoryDecompressionMethodFlagsNV(pub(crate) Flags64);
+vk_bitflags_wrapped!(MemoryDecompressionMethodFlagsNV, Flags64);
+impl MemoryDecompressionMethodFlagsNV {
+    pub const GDEFLATE_1_0: Self = Self(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html>"]
 pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, 0b11, Flags);
+vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, Flags);
 impl PerformanceCounterDescriptionFlagsKHR {
     pub const PERFORMANCE_IMPACTING: Self = Self(0b1);
     pub const CONCURRENTLY_IMPACTED: Self = Self(0b10);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireProfilingLockFlagBitsKHR.html>"]
 pub struct AcquireProfilingLockFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(AcquireProfilingLockFlagsKHR, Flags);
 impl AcquireProfilingLockFlagsKHR {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCorePropertiesFlagBitsAMD.html>"]
 pub struct ShaderCorePropertiesFlagsAMD(pub(crate) Flags);
-vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, 0b0, Flags);
+vk_bitflags_wrapped!(ShaderCorePropertiesFlagsAMD, Flags);
 impl ShaderCorePropertiesFlagsAMD {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleCreateFlagBits.html>"]
 pub struct ShaderModuleCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(ShaderModuleCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(ShaderModuleCreateFlags, Flags);
 impl ShaderModuleCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCompilerControlFlagBitsAMD.html>"]
 pub struct PipelineCompilerControlFlagsAMD(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineCompilerControlFlagsAMD, Flags);
 impl PipelineCompilerControlFlagsAMD {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkToolPurposeFlagBitsEXT.html>"]
-pub struct ToolPurposeFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(ToolPurposeFlagsEXT, 0b1_1111, Flags);
-impl ToolPurposeFlagsEXT {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkToolPurposeFlagBits.html>"]
+pub struct ToolPurposeFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(ToolPurposeFlags, Flags);
+impl ToolPurposeFlags {
     pub const VALIDATION: Self = Self(0b1);
+    pub const VALIDATION_EXT: Self = Self::VALIDATION;
     pub const PROFILING: Self = Self(0b10);
+    pub const PROFILING_EXT: Self = Self::PROFILING;
     pub const TRACING: Self = Self(0b100);
+    pub const TRACING_EXT: Self = Self::TRACING;
     pub const ADDITIONAL_FEATURES: Self = Self(0b1000);
+    pub const ADDITIONAL_FEATURES_EXT: Self = Self::ADDITIONAL_FEATURES;
     pub const MODIFYING_FEATURES: Self = Self(0b1_0000);
+    pub const MODIFYING_FEATURES_EXT: Self = Self::MODIFYING_FEATURES;
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccessFlagBits2KHR.html>"]
-pub struct AccessFlags2KHR(pub(crate) Flags64);
-vk_bitflags_wrapped!(
-    AccessFlags2KHR,
-    0b111_0000_0000_0000_0001_1111_1111_1111_1111,
-    Flags64
-);
-impl AccessFlags2KHR {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccessFlagBits2.html>"]
+pub struct AccessFlags2(pub(crate) Flags64);
+vk_bitflags_wrapped!(AccessFlags2, Flags64);
+impl AccessFlags2 {
     pub const NONE: Self = Self(0);
+    pub const NONE_KHR: Self = Self::NONE;
     pub const INDIRECT_COMMAND_READ: Self = Self(0b1);
+    pub const INDIRECT_COMMAND_READ_KHR: Self = Self::INDIRECT_COMMAND_READ;
     pub const INDEX_READ: Self = Self(0b10);
+    pub const INDEX_READ_KHR: Self = Self::INDEX_READ;
     pub const VERTEX_ATTRIBUTE_READ: Self = Self(0b100);
+    pub const VERTEX_ATTRIBUTE_READ_KHR: Self = Self::VERTEX_ATTRIBUTE_READ;
     pub const UNIFORM_READ: Self = Self(0b1000);
+    pub const UNIFORM_READ_KHR: Self = Self::UNIFORM_READ;
     pub const INPUT_ATTACHMENT_READ: Self = Self(0b1_0000);
+    pub const INPUT_ATTACHMENT_READ_KHR: Self = Self::INPUT_ATTACHMENT_READ;
     pub const SHADER_READ: Self = Self(0b10_0000);
+    pub const SHADER_READ_KHR: Self = Self::SHADER_READ;
     pub const SHADER_WRITE: Self = Self(0b100_0000);
+    pub const SHADER_WRITE_KHR: Self = Self::SHADER_WRITE;
     pub const COLOR_ATTACHMENT_READ: Self = Self(0b1000_0000);
+    pub const COLOR_ATTACHMENT_READ_KHR: Self = Self::COLOR_ATTACHMENT_READ;
     pub const COLOR_ATTACHMENT_WRITE: Self = Self(0b1_0000_0000);
+    pub const COLOR_ATTACHMENT_WRITE_KHR: Self = Self::COLOR_ATTACHMENT_WRITE;
     pub const DEPTH_STENCIL_ATTACHMENT_READ: Self = Self(0b10_0000_0000);
+    pub const DEPTH_STENCIL_ATTACHMENT_READ_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT_READ;
     pub const DEPTH_STENCIL_ATTACHMENT_WRITE: Self = Self(0b100_0000_0000);
+    pub const DEPTH_STENCIL_ATTACHMENT_WRITE_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT_WRITE;
     pub const TRANSFER_READ: Self = Self(0b1000_0000_0000);
+    pub const TRANSFER_READ_KHR: Self = Self::TRANSFER_READ;
     pub const TRANSFER_WRITE: Self = Self(0b1_0000_0000_0000);
+    pub const TRANSFER_WRITE_KHR: Self = Self::TRANSFER_WRITE;
     pub const HOST_READ: Self = Self(0b10_0000_0000_0000);
+    pub const HOST_READ_KHR: Self = Self::HOST_READ;
     pub const HOST_WRITE: Self = Self(0b100_0000_0000_0000);
+    pub const HOST_WRITE_KHR: Self = Self::HOST_WRITE;
     pub const MEMORY_READ: Self = Self(0b1000_0000_0000_0000);
+    pub const MEMORY_READ_KHR: Self = Self::MEMORY_READ;
     pub const MEMORY_WRITE: Self = Self(0b1_0000_0000_0000_0000);
+    pub const MEMORY_WRITE_KHR: Self = Self::MEMORY_WRITE;
     pub const SHADER_SAMPLED_READ: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const SHADER_SAMPLED_READ_KHR: Self = Self::SHADER_SAMPLED_READ;
     pub const SHADER_STORAGE_READ: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const SHADER_STORAGE_READ_KHR: Self = Self::SHADER_STORAGE_READ;
     pub const SHADER_STORAGE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const SHADER_STORAGE_WRITE_KHR: Self = Self::SHADER_STORAGE_WRITE;
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineStageFlagBits2KHR.html>"]
-pub struct PipelineStageFlags2KHR(pub(crate) Flags64);
-vk_bitflags_wrapped!(
-    PipelineStageFlags2KHR,
-    0b111_1111_0000_0000_0000_0001_1111_1111_1111_1111,
-    Flags64
-);
-impl PipelineStageFlags2KHR {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineStageFlagBits2.html>"]
+pub struct PipelineStageFlags2(pub(crate) Flags64);
+vk_bitflags_wrapped!(PipelineStageFlags2, Flags64);
+impl PipelineStageFlags2 {
     pub const NONE: Self = Self(0);
+    pub const NONE_KHR: Self = Self::NONE;
     pub const TOP_OF_PIPE: Self = Self(0b1);
+    pub const TOP_OF_PIPE_KHR: Self = Self::TOP_OF_PIPE;
     pub const DRAW_INDIRECT: Self = Self(0b10);
+    pub const DRAW_INDIRECT_KHR: Self = Self::DRAW_INDIRECT;
     pub const VERTEX_INPUT: Self = Self(0b100);
+    pub const VERTEX_INPUT_KHR: Self = Self::VERTEX_INPUT;
     pub const VERTEX_SHADER: Self = Self(0b1000);
+    pub const VERTEX_SHADER_KHR: Self = Self::VERTEX_SHADER;
     pub const TESSELLATION_CONTROL_SHADER: Self = Self(0b1_0000);
+    pub const TESSELLATION_CONTROL_SHADER_KHR: Self = Self::TESSELLATION_CONTROL_SHADER;
     pub const TESSELLATION_EVALUATION_SHADER: Self = Self(0b10_0000);
+    pub const TESSELLATION_EVALUATION_SHADER_KHR: Self = Self::TESSELLATION_EVALUATION_SHADER;
     pub const GEOMETRY_SHADER: Self = Self(0b100_0000);
+    pub const GEOMETRY_SHADER_KHR: Self = Self::GEOMETRY_SHADER;
     pub const FRAGMENT_SHADER: Self = Self(0b1000_0000);
+    pub const FRAGMENT_SHADER_KHR: Self = Self::FRAGMENT_SHADER;
     pub const EARLY_FRAGMENT_TESTS: Self = Self(0b1_0000_0000);
+    pub const EARLY_FRAGMENT_TESTS_KHR: Self = Self::EARLY_FRAGMENT_TESTS;
     pub const LATE_FRAGMENT_TESTS: Self = Self(0b10_0000_0000);
+    pub const LATE_FRAGMENT_TESTS_KHR: Self = Self::LATE_FRAGMENT_TESTS;
     pub const COLOR_ATTACHMENT_OUTPUT: Self = Self(0b100_0000_0000);
+    pub const COLOR_ATTACHMENT_OUTPUT_KHR: Self = Self::COLOR_ATTACHMENT_OUTPUT;
     pub const COMPUTE_SHADER: Self = Self(0b1000_0000_0000);
+    pub const COMPUTE_SHADER_KHR: Self = Self::COMPUTE_SHADER;
     pub const ALL_TRANSFER: Self = Self(0b1_0000_0000_0000);
-    pub const TRANSFER: Self = Self::ALL_TRANSFER;
+    pub const ALL_TRANSFER_KHR: Self = Self::ALL_TRANSFER;
+    pub const TRANSFER: Self = Self::ALL_TRANSFER_KHR;
+    pub const TRANSFER_KHR: Self = Self::ALL_TRANSFER;
     pub const BOTTOM_OF_PIPE: Self = Self(0b10_0000_0000_0000);
+    pub const BOTTOM_OF_PIPE_KHR: Self = Self::BOTTOM_OF_PIPE;
     pub const HOST: Self = Self(0b100_0000_0000_0000);
+    pub const HOST_KHR: Self = Self::HOST;
     pub const ALL_GRAPHICS: Self = Self(0b1000_0000_0000_0000);
+    pub const ALL_GRAPHICS_KHR: Self = Self::ALL_GRAPHICS;
     pub const ALL_COMMANDS: Self = Self(0b1_0000_0000_0000_0000);
+    pub const ALL_COMMANDS_KHR: Self = Self::ALL_COMMANDS;
     pub const COPY: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const COPY_KHR: Self = Self::COPY;
     pub const RESOLVE: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const RESOLVE_KHR: Self = Self::RESOLVE;
     pub const BLIT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const BLIT_KHR: Self = Self::BLIT;
     pub const CLEAR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const CLEAR_KHR: Self = Self::CLEAR;
     pub const INDEX_INPUT: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const INDEX_INPUT_KHR: Self = Self::INDEX_INPUT;
     pub const VERTEX_ATTRIBUTE_INPUT: Self =
         Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const VERTEX_ATTRIBUTE_INPUT_KHR: Self = Self::VERTEX_ATTRIBUTE_INPUT;
     pub const PRE_RASTERIZATION_SHADERS: Self =
         Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const PRE_RASTERIZATION_SHADERS_KHR: Self = Self::PRE_RASTERIZATION_SHADERS;
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubmitFlagBitsKHR.html>"]
-pub struct SubmitFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(SubmitFlagsKHR, 0b1, Flags);
-impl SubmitFlagsKHR {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitFlagBits.html>"]
+pub struct SubmitFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(SubmitFlags, Flags);
+impl SubmitFlags {
     pub const PROTECTED: Self = Self(0b1);
+    pub const PROTECTED_KHR: Self = Self::PROTECTED;
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEventCreateFlagBits.html>"]
 pub struct EventCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(EventCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(EventCreateFlags, Flags);
 impl EventCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateFlagBits.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayoutCreateFlagBits.html>"]
 pub struct PipelineLayoutCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineLayoutCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineLayoutCreateFlags, Flags);
 impl PipelineLayoutCreateFlags {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendStateCreateFlagBits.html>"]
+pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, Flags);
+impl PipelineColorBlendStateCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDepthStencilStateCreateFlagBits.html>"]
+pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, Flags);
+impl PipelineDepthStencilStateCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineLibraryFlagBitsEXT.html>"]
+pub struct GraphicsPipelineLibraryFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(GraphicsPipelineLibraryFlagsEXT, Flags);
+impl GraphicsPipelineLibraryFlagsEXT {
+    pub const VERTEX_INPUT_INTERFACE: Self = Self(0b1);
+    pub const PRE_RASTERIZATION_SHADERS: Self = Self(0b10);
+    pub const FRAGMENT_SHADER: Self = Self(0b100);
+    pub const FRAGMENT_OUTPUT_INTERFACE: Self = Self(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddressBindingFlagBitsEXT.html>"]
+pub struct DeviceAddressBindingFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(DeviceAddressBindingFlagsEXT, Flags);
+impl DeviceAddressBindingFlagsEXT {
+    pub const INTERNAL_OBJECT: Self = Self(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentScalingFlagBitsEXT.html>"]
+pub struct PresentScalingFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(PresentScalingFlagsEXT, Flags);
+impl PresentScalingFlagsEXT {
+    pub const ONE_TO_ONE: Self = Self(0b1);
+    pub const ASPECT_RATIO_STRETCH: Self = Self(0b10);
+    pub const STRETCH: Self = Self(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentGravityFlagBitsEXT.html>"]
+pub struct PresentGravityFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(PresentGravityFlagsEXT, Flags);
+impl PresentGravityFlagsEXT {
+    pub const MIN: Self = Self(0b1);
+    pub const MAX: Self = Self(0b10);
+    pub const CENTERED: Self = Self(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html>"]
 pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags);
 impl VideoCodecOperationFlagsKHR {
-    pub const INVALID: Self = Self(0);
+    pub const NONE: Self = Self(0);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html>"]
 pub struct VideoChromaSubsamplingFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoChromaSubsamplingFlagsKHR, 0b1111, Flags);
+vk_bitflags_wrapped!(VideoChromaSubsamplingFlagsKHR, Flags);
 impl VideoChromaSubsamplingFlagsKHR {
     pub const INVALID: Self = Self(0);
     pub const MONOCHROME: Self = Self(0b1);
@@ -1081,9 +1183,9 @@ impl VideoChromaSubsamplingFlagsKHR {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoComponentBitDepthFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoComponentBitDepthFlagBitsKHR.html>"]
 pub struct VideoComponentBitDepthFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoComponentBitDepthFlagsKHR, 0b1_0101, Flags);
+vk_bitflags_wrapped!(VideoComponentBitDepthFlagsKHR, Flags);
 impl VideoComponentBitDepthFlagsKHR {
     pub const INVALID: Self = Self(0);
     pub const TYPE_8: Self = Self(0b1);
@@ -1092,132 +1194,430 @@ impl VideoComponentBitDepthFlagsKHR {
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCapabilityFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilityFlagBitsKHR.html>"]
 pub struct VideoCapabilityFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoCapabilityFlagsKHR, 0b11, Flags);
+vk_bitflags_wrapped!(VideoCapabilityFlagsKHR, Flags);
 impl VideoCapabilityFlagsKHR {
     pub const PROTECTED_CONTENT: Self = Self(0b1);
     pub const SEPARATE_REFERENCE_IMAGES: Self = Self(0b10);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionCreateFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateFlagBitsKHR.html>"]
 pub struct VideoSessionCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, 0b1, Flags);
+vk_bitflags_wrapped!(VideoSessionCreateFlagsKHR, Flags);
 impl VideoSessionCreateFlagsKHR {
-    pub const DEFAULT: Self = Self(0);
     pub const PROTECTED_CONTENT: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingQualityPresetFlagBitsKHR.html>"]
-pub struct VideoCodingQualityPresetFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoCodingQualityPresetFlagsKHR, 0b111, Flags);
-impl VideoCodingQualityPresetFlagsKHR {
-    pub const NORMAL: Self = Self(0b1);
-    pub const POWER: Self = Self(0b10);
-    pub const QUALITY: Self = Self(0b100);
-}
-#[repr(transparent)]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsEXT.html>"]
-pub struct VideoDecodeH264PictureLayoutFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsEXT, 0b11, Flags);
-impl VideoDecodeH264PictureLayoutFlagsEXT {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureLayoutFlagBitsKHR.html>"]
+pub struct VideoDecodeH264PictureLayoutFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoDecodeH264PictureLayoutFlagsKHR, Flags);
+impl VideoDecodeH264PictureLayoutFlagsKHR {
     pub const PROGRESSIVE: Self = Self(0);
     pub const INTERLACED_INTERLEAVED_LINES: Self = Self(0b1);
     pub const INTERLACED_SEPARATE_PLANES: Self = Self(0b10);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingControlFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlFlagBitsKHR.html>"]
 pub struct VideoCodingControlFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, 0b1, Flags);
+vk_bitflags_wrapped!(VideoCodingControlFlagsKHR, Flags);
 impl VideoCodingControlFlagsKHR {
-    pub const DEFAULT: Self = Self(0);
     pub const RESET: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeFlagBitsKHR.html>"]
-pub struct VideoDecodeFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoDecodeFlagsKHR, 0b1, Flags);
-impl VideoDecodeFlagsKHR {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeUsageFlagBitsKHR.html>"]
+pub struct VideoDecodeUsageFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoDecodeUsageFlagsKHR, Flags);
+impl VideoDecodeUsageFlagsKHR {
     pub const DEFAULT: Self = Self(0);
-    pub const RESERVED_0: Self = Self(0b1);
+    pub const TRANSCODING: Self = Self(0b1);
+    pub const OFFLINE: Self = Self(0b10);
+    pub const STREAMING: Self = Self(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeCapabilityFlagBitsKHR.html>"]
+pub struct VideoDecodeCapabilityFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoDecodeCapabilityFlagsKHR, Flags);
+impl VideoDecodeCapabilityFlagsKHR {
+    pub const DPB_AND_OUTPUT_COINCIDE: Self = Self(0b1);
+    pub const DPB_AND_OUTPUT_DISTINCT: Self = Self(0b10);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeFlagBitsKHR.html>"]
-pub struct VideoEncodeFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeFlagsKHR, 0b1, Flags);
-impl VideoEncodeFlagsKHR {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeUsageFlagBitsKHR.html>"]
+pub struct VideoEncodeUsageFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeUsageFlagsKHR, Flags);
+impl VideoEncodeUsageFlagsKHR {
     pub const DEFAULT: Self = Self(0);
-    pub const RESERVED_0: Self = Self(0b1);
+    pub const TRANSCODING: Self = Self(0b1);
+    pub const STREAMING: Self = Self(0b10);
+    pub const RECORDING: Self = Self(0b100);
+    pub const CONFERENCING: Self = Self(0b1000);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlFlagBitsKHR.html>"]
-pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, 0b1, Flags);
-impl VideoEncodeRateControlFlagsKHR {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeContentFlagBitsKHR.html>"]
+pub struct VideoEncodeContentFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeContentFlagsKHR, Flags);
+impl VideoEncodeContentFlagsKHR {
     pub const DEFAULT: Self = Self(0);
-    pub const RESET: Self = Self(0b1);
+    pub const CAMERA: Self = Self(0b1);
+    pub const DESKTOP: Self = Self(0b10);
+    pub const RENDERED: Self = Self(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeCapabilityFlagBitsKHR.html>"]
+pub struct VideoEncodeCapabilityFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeCapabilityFlagsKHR, Flags);
+impl VideoEncodeCapabilityFlagsKHR {
+    pub const PRECEDING_EXTERNALLY_ENCODED_BYTES: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeFeedbackFlagBitsKHR.html>"]
+pub struct VideoEncodeFeedbackFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeFeedbackFlagsKHR, Flags);
+impl VideoEncodeFeedbackFlagsKHR {
+    pub const BITSTREAM_BUFFER_OFFSET: Self = Self(0b1);
+    pub const BITSTREAM_BYTES_WRITTEN: Self = Self(0b10);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html>"]
 pub struct VideoEncodeRateControlModeFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, 0b11, Flags);
+vk_bitflags_wrapped!(VideoEncodeRateControlModeFlagsKHR, Flags);
 impl VideoEncodeRateControlModeFlagsKHR {
-    pub const NONE: Self = Self(0);
-    pub const CBR: Self = Self(1);
-    pub const VBR: Self = Self(2);
+    pub const DEFAULT: Self = Self(0);
+    pub const DISABLED: Self = Self(0b1);
+    pub const CBR: Self = Self(0b10);
+    pub const VBR: Self = Self(0b100);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CapabilityFlagBitsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264CapabilityFlagBitsEXT.html>"]
 pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, 0b111_1111_1111, Flags);
+vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags);
 impl VideoEncodeH264CapabilityFlagsEXT {
-    pub const CABAC: Self = Self(0b1);
-    pub const CAVLC: Self = Self(0b10);
-    pub const WEIGHTED_BI_PRED_IMPLICIT: Self = Self(0b100);
-    pub const TRANSFORM_8X8: Self = Self(0b1000);
-    pub const CHROMA_QP_OFFSET: Self = Self(0b1_0000);
-    pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b10_0000);
-    pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b100_0000);
-    pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b1000_0000);
-    pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b1_0000_0000);
-    pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b10_0000_0000);
-    pub const EVENLY_DISTRIBUTED_SLICE_SIZE: Self = Self(0b100_0000_0000);
-}
-#[repr(transparent)]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264InputModeFlagBitsEXT.html>"]
-pub struct VideoEncodeH264InputModeFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeH264InputModeFlagsEXT, 0b111, Flags);
-impl VideoEncodeH264InputModeFlagsEXT {
-    pub const FRAME: Self = Self(0b1);
-    pub const SLICE: Self = Self(0b10);
-    pub const NON_VCL: Self = Self(0b100);
+    pub const DIRECT_8X8_INFERENCE_ENABLED: Self = Self(0b1);
+    pub const DIRECT_8X8_INFERENCE_DISABLED: Self = Self(0b10);
+    pub const SEPARATE_COLOUR_PLANE: Self = Self(0b100);
+    pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS: Self = Self(0b1000);
+    pub const SCALING_LISTS: Self = Self(0b1_0000);
+    pub const HRD_COMPLIANCE: Self = Self(0b10_0000);
+    pub const CHROMA_QP_OFFSET: Self = Self(0b100_0000);
+    pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b1000_0000);
+    pub const PIC_INIT_QP_MINUS26: Self = Self(0b1_0000_0000);
+    pub const WEIGHTED_PRED: Self = Self(0b10_0000_0000);
+    pub const WEIGHTED_BIPRED_EXPLICIT: Self = Self(0b100_0000_0000);
+    pub const WEIGHTED_BIPRED_IMPLICIT: Self = Self(0b1000_0000_0000);
+    pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b1_0000_0000_0000);
+    pub const TRANSFORM_8X8: Self = Self(0b10_0000_0000_0000);
+    pub const CABAC: Self = Self(0b100_0000_0000_0000);
+    pub const CAVLC: Self = Self(0b1000_0000_0000_0000);
+    pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1_0000_0000_0000_0000);
+    pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b10_0000_0000_0000_0000);
+    pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b100_0000_0000_0000_0000);
+    pub const DISABLE_DIRECT_SPATIAL_MV_PRED: Self = Self(0b1000_0000_0000_0000_0000);
+    pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b1_0000_0000_0000_0000_0000);
+    pub const SLICE_MB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000);
+    pub const ROW_UNALIGNED_SLICE: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000_0000_0000_0000_0000_0000);
+    pub const B_FRAME_IN_L1_LIST: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+    pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatConstraintsFlagBitsFUCHSIA.html>"]
+pub struct ImageFormatConstraintsFlagsFUCHSIA(pub(crate) Flags);
+vk_bitflags_wrapped!(ImageFormatConstraintsFlagsFUCHSIA, Flags);
+impl ImageFormatConstraintsFlagsFUCHSIA {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageConstraintsInfoFlagBitsFUCHSIA.html>"]
+pub struct ImageConstraintsInfoFlagsFUCHSIA(pub(crate) Flags);
+vk_bitflags_wrapped!(ImageConstraintsInfoFlagsFUCHSIA, Flags);
+impl ImageConstraintsInfoFlagsFUCHSIA {
+    pub const CPU_READ_RARELY: Self = Self(0b1);
+    pub const CPU_READ_OFTEN: Self = Self(0b10);
+    pub const CPU_WRITE_RARELY: Self = Self(0b100);
+    pub const CPU_WRITE_OFTEN: Self = Self(0b1000);
+    pub const PROTECTED_OPTIONAL: Self = Self(0b1_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatFeatureFlagBits2.html>"]
+pub struct FormatFeatureFlags2(pub(crate) Flags64);
+vk_bitflags_wrapped!(FormatFeatureFlags2, Flags64);
+impl FormatFeatureFlags2 {
+    pub const SAMPLED_IMAGE: Self = Self(0b1);
+    pub const SAMPLED_IMAGE_KHR: Self = Self::SAMPLED_IMAGE;
+    pub const STORAGE_IMAGE: Self = Self(0b10);
+    pub const STORAGE_IMAGE_KHR: Self = Self::STORAGE_IMAGE;
+    pub const STORAGE_IMAGE_ATOMIC: Self = Self(0b100);
+    pub const STORAGE_IMAGE_ATOMIC_KHR: Self = Self::STORAGE_IMAGE_ATOMIC;
+    pub const UNIFORM_TEXEL_BUFFER: Self = Self(0b1000);
+    pub const UNIFORM_TEXEL_BUFFER_KHR: Self = Self::UNIFORM_TEXEL_BUFFER;
+    pub const STORAGE_TEXEL_BUFFER: Self = Self(0b1_0000);
+    pub const STORAGE_TEXEL_BUFFER_KHR: Self = Self::STORAGE_TEXEL_BUFFER;
+    pub const STORAGE_TEXEL_BUFFER_ATOMIC: Self = Self(0b10_0000);
+    pub const STORAGE_TEXEL_BUFFER_ATOMIC_KHR: Self = Self::STORAGE_TEXEL_BUFFER_ATOMIC;
+    pub const VERTEX_BUFFER: Self = Self(0b100_0000);
+    pub const VERTEX_BUFFER_KHR: Self = Self::VERTEX_BUFFER;
+    pub const COLOR_ATTACHMENT: Self = Self(0b1000_0000);
+    pub const COLOR_ATTACHMENT_KHR: Self = Self::COLOR_ATTACHMENT;
+    pub const COLOR_ATTACHMENT_BLEND: Self = Self(0b1_0000_0000);
+    pub const COLOR_ATTACHMENT_BLEND_KHR: Self = Self::COLOR_ATTACHMENT_BLEND;
+    pub const DEPTH_STENCIL_ATTACHMENT: Self = Self(0b10_0000_0000);
+    pub const DEPTH_STENCIL_ATTACHMENT_KHR: Self = Self::DEPTH_STENCIL_ATTACHMENT;
+    pub const BLIT_SRC: Self = Self(0b100_0000_0000);
+    pub const BLIT_SRC_KHR: Self = Self::BLIT_SRC;
+    pub const BLIT_DST: Self = Self(0b1000_0000_0000);
+    pub const BLIT_DST_KHR: Self = Self::BLIT_DST;
+    pub const SAMPLED_IMAGE_FILTER_LINEAR: Self = Self(0b1_0000_0000_0000);
+    pub const SAMPLED_IMAGE_FILTER_LINEAR_KHR: Self = Self::SAMPLED_IMAGE_FILTER_LINEAR;
+    pub const SAMPLED_IMAGE_FILTER_CUBIC: Self = Self(0b10_0000_0000_0000);
+    pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC;
+    pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000);
+    pub const TRANSFER_SRC_KHR: Self = Self::TRANSFER_SRC;
+    pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000);
+    pub const TRANSFER_DST_KHR: Self = Self::TRANSFER_DST;
+    pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000);
+    pub const SAMPLED_IMAGE_FILTER_MINMAX_KHR: Self = Self::SAMPLED_IMAGE_FILTER_MINMAX;
+    pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000);
+    pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = Self::MIDPOINT_CHROMA_SAMPLES;
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000);
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self =
+        Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER;
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self =
+        Self(0b1000_0000_0000_0000_0000);
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self =
+        Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER;
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self =
+        Self(0b1_0000_0000_0000_0000_0000);
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self =
+        Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT;
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self =
+        Self(0b10_0000_0000_0000_0000_0000);
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self =
+        Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE;
+    pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const DISJOINT_KHR: Self = Self::DISJOINT;
+    pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000);
+    pub const COSITED_CHROMA_SAMPLES_KHR: Self = Self::COSITED_CHROMA_SAMPLES;
+    pub const STORAGE_READ_WITHOUT_FORMAT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000);
+    pub const STORAGE_READ_WITHOUT_FORMAT_KHR: Self = Self::STORAGE_READ_WITHOUT_FORMAT;
+    pub const STORAGE_WRITE_WITHOUT_FORMAT: Self =
+        Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const STORAGE_WRITE_WITHOUT_FORMAT_KHR: Self = Self::STORAGE_WRITE_WITHOUT_FORMAT;
+    pub const SAMPLED_IMAGE_DEPTH_COMPARISON: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const SAMPLED_IMAGE_DEPTH_COMPARISON_KHR: Self = Self::SAMPLED_IMAGE_DEPTH_COMPARISON;
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFlagBits.html>"]
+pub struct RenderingFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(RenderingFlags, Flags);
+impl RenderingFlags {
+    pub const CONTENTS_SECONDARY_COMMAND_BUFFERS: Self = Self(0b1);
+    pub const CONTENTS_SECONDARY_COMMAND_BUFFERS_KHR: Self =
+        Self::CONTENTS_SECONDARY_COMMAND_BUFFERS;
+    pub const SUSPENDING: Self = Self(0b10);
+    pub const SUSPENDING_KHR: Self = Self::SUSPENDING;
+    pub const RESUMING: Self = Self(0b100);
+    pub const RESUMING_KHR: Self = Self::RESUMING;
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265CapabilityFlagBitsEXT.html>"]
+pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, Flags);
+impl VideoEncodeH265CapabilityFlagsEXT {
+    pub const SEPARATE_COLOUR_PLANE: Self = Self(0b1);
+    pub const SCALING_LISTS: Self = Self(0b10);
+    pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED: Self = Self(0b100);
+    pub const PCM_ENABLE: Self = Self(0b1000);
+    pub const SPS_TEMPORAL_MVP_ENABLED: Self = Self(0b1_0000);
+    pub const HRD_COMPLIANCE: Self = Self(0b10_0000);
+    pub const INIT_QP_MINUS26: Self = Self(0b100_0000);
+    pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1000_0000);
+    pub const SIGN_DATA_HIDING_ENABLED: Self = Self(0b1_0000_0000);
+    pub const TRANSFORM_SKIP_ENABLED: Self = Self(0b10_0000_0000);
+    pub const TRANSFORM_SKIP_DISABLED: Self = Self(0b100_0000_0000);
+    pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT: Self = Self(0b1000_0000_0000);
+    pub const WEIGHTED_PRED: Self = Self(0b1_0000_0000_0000);
+    pub const WEIGHTED_BIPRED: Self = Self(0b10_0000_0000_0000);
+    pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b100_0000_0000_0000);
+    pub const TRANSQUANT_BYPASS_ENABLED: Self = Self(0b1000_0000_0000_0000);
+    pub const ENTROPY_CODING_SYNC_ENABLED: Self = Self(0b1_0000_0000_0000_0000);
+    pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED: Self = Self(0b10_0000_0000_0000_0000);
+    pub const MULTIPLE_TILE_PER_FRAME: Self = Self(0b100_0000_0000_0000_0000);
+    pub const MULTIPLE_SLICE_PER_TILE: Self = Self(0b1000_0000_0000_0000_0000);
+    pub const MULTIPLE_TILE_PER_SLICE: Self = Self(0b1_0000_0000_0000_0000_0000);
+    pub const SLICE_SEGMENT_CTB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000);
+    pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const DEPENDENT_SLICE_SEGMENT: Self = Self(0b1000_0000_0000_0000_0000_0000);
+    pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+    pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
+    pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265CtbSizeFlagBitsEXT.html>"]
+pub struct VideoEncodeH265CtbSizeFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeH265CtbSizeFlagsEXT, Flags);
+impl VideoEncodeH265CtbSizeFlagsEXT {
+    pub const TYPE_16: Self = Self(0b1);
+    pub const TYPE_32: Self = Self(0b10);
+    pub const TYPE_64: Self = Self(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265TransformBlockSizeFlagBitsEXT.html>"]
+pub struct VideoEncodeH265TransformBlockSizeFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeH265TransformBlockSizeFlagsEXT, Flags);
+impl VideoEncodeH265TransformBlockSizeFlagsEXT {
+    pub const TYPE_4: Self = Self(0b1);
+    pub const TYPE_8: Self = Self(0b10);
+    pub const TYPE_16: Self = Self(0b100);
+    pub const TYPE_32: Self = Self(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalObjectTypeFlagBitsEXT.html>"]
+pub struct ExportMetalObjectTypeFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(ExportMetalObjectTypeFlagsEXT, Flags);
+impl ExportMetalObjectTypeFlagsEXT {
+    pub const METAL_DEVICE: Self = Self(0b1);
+    pub const METAL_COMMAND_QUEUE: Self = Self(0b10);
+    pub const METAL_BUFFER: Self = Self(0b100);
+    pub const METAL_TEXTURE: Self = Self(0b1000);
+    pub const METAL_IOSURFACE: Self = Self(0b1_0000);
+    pub const METAL_SHARED_EVENT: Self = Self(0b10_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateFlagBits.html>"]
+pub struct InstanceCreateFlags(pub(crate) Flags);
+vk_bitflags_wrapped!(InstanceCreateFlags, Flags);
+impl InstanceCreateFlags {}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFlagBitsEXT.html>"]
+pub struct ImageCompressionFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(ImageCompressionFlagsEXT, Flags);
+impl ImageCompressionFlagsEXT {
+    pub const DEFAULT: Self = Self(0);
+    pub const FIXED_RATE_DEFAULT: Self = Self(0b1);
+    pub const FIXED_RATE_EXPLICIT: Self = Self(0b10);
+    pub const DISABLED: Self = Self(0b100);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264OutputModeFlagBitsEXT.html>"]
-pub struct VideoEncodeH264OutputModeFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeH264OutputModeFlagsEXT, 0b111, Flags);
-impl VideoEncodeH264OutputModeFlagsEXT {
-    pub const FRAME: Self = Self(0b1);
-    pub const SLICE: Self = Self(0b10);
-    pub const NON_VCL: Self = Self(0b100);
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionFixedRateFlagBitsEXT.html>"]
+pub struct ImageCompressionFixedRateFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(ImageCompressionFixedRateFlagsEXT, Flags);
+impl ImageCompressionFixedRateFlagsEXT {
+    pub const NONE: Self = Self(0);
+    pub const TYPE_1BPC: Self = Self(0b1);
+    pub const TYPE_2BPC: Self = Self(0b10);
+    pub const TYPE_3BPC: Self = Self(0b100);
+    pub const TYPE_4BPC: Self = Self(0b1000);
+    pub const TYPE_5BPC: Self = Self(0b1_0000);
+    pub const TYPE_6BPC: Self = Self(0b10_0000);
+    pub const TYPE_7BPC: Self = Self(0b100_0000);
+    pub const TYPE_8BPC: Self = Self(0b1000_0000);
+    pub const TYPE_9BPC: Self = Self(0b1_0000_0000);
+    pub const TYPE_10BPC: Self = Self(0b10_0000_0000);
+    pub const TYPE_11BPC: Self = Self(0b100_0000_0000);
+    pub const TYPE_12BPC: Self = Self(0b1000_0000_0000);
+    pub const TYPE_13BPC: Self = Self(0b1_0000_0000_0000);
+    pub const TYPE_14BPC: Self = Self(0b10_0000_0000_0000);
+    pub const TYPE_15BPC: Self = Self(0b100_0000_0000_0000);
+    pub const TYPE_16BPC: Self = Self(0b1000_0000_0000_0000);
+    pub const TYPE_17BPC: Self = Self(0b1_0000_0000_0000_0000);
+    pub const TYPE_18BPC: Self = Self(0b10_0000_0000_0000_0000);
+    pub const TYPE_19BPC: Self = Self(0b100_0000_0000_0000_0000);
+    pub const TYPE_20BPC: Self = Self(0b1000_0000_0000_0000_0000);
+    pub const TYPE_21BPC: Self = Self(0b1_0000_0000_0000_0000_0000);
+    pub const TYPE_22BPC: Self = Self(0b10_0000_0000_0000_0000_0000);
+    pub const TYPE_23BPC: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const TYPE_24BPC: Self = Self(0b1000_0000_0000_0000_0000_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowGridSizeFlagBitsNV.html>"]
+pub struct OpticalFlowGridSizeFlagsNV(pub(crate) Flags);
+vk_bitflags_wrapped!(OpticalFlowGridSizeFlagsNV, Flags);
+impl OpticalFlowGridSizeFlagsNV {
+    pub const UNKNOWN: Self = Self(0);
+    pub const TYPE_1X1: Self = Self(0b1);
+    pub const TYPE_2X2: Self = Self(0b10);
+    pub const TYPE_4X4: Self = Self(0b100);
+    pub const TYPE_8X8: Self = Self(0b1000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowUsageFlagBitsNV.html>"]
+pub struct OpticalFlowUsageFlagsNV(pub(crate) Flags);
+vk_bitflags_wrapped!(OpticalFlowUsageFlagsNV, Flags);
+impl OpticalFlowUsageFlagsNV {
+    pub const UNKNOWN: Self = Self(0);
+    pub const INPUT: Self = Self(0b1);
+    pub const OUTPUT: Self = Self(0b10);
+    pub const HINT: Self = Self(0b100);
+    pub const COST: Self = Self(0b1000);
+    pub const GLOBAL_FLOW: Self = Self(0b1_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionCreateFlagBitsNV.html>"]
+pub struct OpticalFlowSessionCreateFlagsNV(pub(crate) Flags);
+vk_bitflags_wrapped!(OpticalFlowSessionCreateFlagsNV, Flags);
+impl OpticalFlowSessionCreateFlagsNV {
+    pub const ENABLE_HINT: Self = Self(0b1);
+    pub const ENABLE_COST: Self = Self(0b10);
+    pub const ENABLE_GLOBAL_FLOW: Self = Self(0b100);
+    pub const ALLOW_REGIONS: Self = Self(0b1000);
+    pub const BOTH_DIRECTIONS: Self = Self(0b1_0000);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowExecuteFlagBitsNV.html>"]
+pub struct OpticalFlowExecuteFlagsNV(pub(crate) Flags);
+vk_bitflags_wrapped!(OpticalFlowExecuteFlagsNV, Flags);
+impl OpticalFlowExecuteFlagsNV {
+    pub const DISABLE_TEMPORAL_HINTS: Self = Self(0b1);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuildMicromapFlagBitsEXT.html>"]
+pub struct BuildMicromapFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(BuildMicromapFlagsEXT, Flags);
+impl BuildMicromapFlagsEXT {
+    pub const PREFER_FAST_TRACE: Self = Self(0b1);
+    pub const PREFER_FAST_BUILD: Self = Self(0b10);
+    pub const ALLOW_COMPACTION: Self = Self(0b100);
+}
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapCreateFlagBitsEXT.html>"]
+pub struct MicromapCreateFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(MicromapCreateFlagsEXT, Flags);
+impl MicromapCreateFlagsEXT {
+    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1);
 }
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CreateFlagBitsEXT.html>"]
-pub struct VideoEncodeH264CreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEncodeH264CreateFlagsEXT, 0b1, Flags);
-impl VideoEncodeH264CreateFlagsEXT {
-    pub const DEFAULT: Self = Self(0);
-    pub const RESERVED_0: Self = Self(0b1);
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCreateFlagBitsEXT.html>"]
+pub struct ShaderCreateFlagsEXT(pub(crate) Flags);
+vk_bitflags_wrapped!(ShaderCreateFlagsEXT, Flags);
+impl ShaderCreateFlagsEXT {
+    pub const LINK_STAGE: Self = Self(0b1);
 }
diff --git a/src/vk/const_debugs.rs b/src/vk/const_debugs.rs
index b4b9219..04ba641 100644
--- a/src/vk/const_debugs.rs
+++ b/src/vk/const_debugs.rs
@@ -1,33 +1,8 @@
+use crate::prelude::debug_flags;
 use crate::vk::bitflags::*;
 use crate::vk::definitions::*;
 use crate::vk::enums::*;
 use std::fmt;
-pub(crate) fn debug_flags<Value: Into<u64> + Copy>(
-    f: &mut fmt::Formatter,
-    known: &[(Value, &'static str)],
-    value: Value,
-) -> fmt::Result {
-    let mut first = true;
-    let mut accum = value.into();
-    for &(bit, name) in known {
-        let bit = bit.into();
-        if bit != 0 && accum & bit == bit {
-            if !first {
-                f.write_str(" | ")?;
-            }
-            f.write_str(name)?;
-            first = false;
-            accum &= !bit;
-        }
-    }
-    if accum != 0 {
-        if !first {
-            f.write_str(" | ")?;
-        }
-        write!(f, "{:b}", accum)?;
-    }
-    Ok(())
-}
 impl fmt::Debug for AccelerationStructureBuildTypeKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -65,6 +40,10 @@ impl fmt::Debug for AccelerationStructureCreateFlagsKHR {
                 "DEVICE_ADDRESS_CAPTURE_REPLAY",
             ),
             (
+                AccelerationStructureCreateFlagsKHR::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
+                "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
+            ),
+            (
                 AccelerationStructureCreateFlagsKHR::MOTION_NV.0,
                 "MOTION_NV",
             ),
@@ -214,117 +193,140 @@ impl fmt::Debug for AccessFlags {
                 AccessFlags::COMMAND_PREPROCESS_WRITE_NV.0,
                 "COMMAND_PREPROCESS_WRITE_NV",
             ),
-            (AccessFlags::NONE_KHR.0, "NONE_KHR"),
+            (AccessFlags::NONE.0, "NONE"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for AccessFlags2KHR {
+impl fmt::Debug for AccessFlags2 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags64, &str)] = &[
-            (AccessFlags2KHR::NONE.0, "NONE"),
+            (AccessFlags2::NONE.0, "NONE"),
             (
-                AccessFlags2KHR::INDIRECT_COMMAND_READ.0,
+                AccessFlags2::INDIRECT_COMMAND_READ.0,
                 "INDIRECT_COMMAND_READ",
             ),
-            (AccessFlags2KHR::INDEX_READ.0, "INDEX_READ"),
+            (AccessFlags2::INDEX_READ.0, "INDEX_READ"),
             (
-                AccessFlags2KHR::VERTEX_ATTRIBUTE_READ.0,
+                AccessFlags2::VERTEX_ATTRIBUTE_READ.0,
                 "VERTEX_ATTRIBUTE_READ",
             ),
-            (AccessFlags2KHR::UNIFORM_READ.0, "UNIFORM_READ"),
+            (AccessFlags2::UNIFORM_READ.0, "UNIFORM_READ"),
             (
-                AccessFlags2KHR::INPUT_ATTACHMENT_READ.0,
+                AccessFlags2::INPUT_ATTACHMENT_READ.0,
                 "INPUT_ATTACHMENT_READ",
             ),
-            (AccessFlags2KHR::SHADER_READ.0, "SHADER_READ"),
-            (AccessFlags2KHR::SHADER_WRITE.0, "SHADER_WRITE"),
+            (AccessFlags2::SHADER_READ.0, "SHADER_READ"),
+            (AccessFlags2::SHADER_WRITE.0, "SHADER_WRITE"),
             (
-                AccessFlags2KHR::COLOR_ATTACHMENT_READ.0,
+                AccessFlags2::COLOR_ATTACHMENT_READ.0,
                 "COLOR_ATTACHMENT_READ",
             ),
             (
-                AccessFlags2KHR::COLOR_ATTACHMENT_WRITE.0,
+                AccessFlags2::COLOR_ATTACHMENT_WRITE.0,
                 "COLOR_ATTACHMENT_WRITE",
             ),
             (
-                AccessFlags2KHR::DEPTH_STENCIL_ATTACHMENT_READ.0,
+                AccessFlags2::DEPTH_STENCIL_ATTACHMENT_READ.0,
                 "DEPTH_STENCIL_ATTACHMENT_READ",
             ),
             (
-                AccessFlags2KHR::DEPTH_STENCIL_ATTACHMENT_WRITE.0,
+                AccessFlags2::DEPTH_STENCIL_ATTACHMENT_WRITE.0,
                 "DEPTH_STENCIL_ATTACHMENT_WRITE",
             ),
-            (AccessFlags2KHR::TRANSFER_READ.0, "TRANSFER_READ"),
-            (AccessFlags2KHR::TRANSFER_WRITE.0, "TRANSFER_WRITE"),
-            (AccessFlags2KHR::HOST_READ.0, "HOST_READ"),
-            (AccessFlags2KHR::HOST_WRITE.0, "HOST_WRITE"),
-            (AccessFlags2KHR::MEMORY_READ.0, "MEMORY_READ"),
-            (AccessFlags2KHR::MEMORY_WRITE.0, "MEMORY_WRITE"),
+            (AccessFlags2::TRANSFER_READ.0, "TRANSFER_READ"),
+            (AccessFlags2::TRANSFER_WRITE.0, "TRANSFER_WRITE"),
+            (AccessFlags2::HOST_READ.0, "HOST_READ"),
+            (AccessFlags2::HOST_WRITE.0, "HOST_WRITE"),
+            (AccessFlags2::MEMORY_READ.0, "MEMORY_READ"),
+            (AccessFlags2::MEMORY_WRITE.0, "MEMORY_WRITE"),
+            (AccessFlags2::SHADER_SAMPLED_READ.0, "SHADER_SAMPLED_READ"),
+            (AccessFlags2::SHADER_STORAGE_READ.0, "SHADER_STORAGE_READ"),
+            (AccessFlags2::SHADER_STORAGE_WRITE.0, "SHADER_STORAGE_WRITE"),
+            (
+                AccessFlags2::VIDEO_DECODE_READ_KHR.0,
+                "VIDEO_DECODE_READ_KHR",
+            ),
             (
-                AccessFlags2KHR::SHADER_SAMPLED_READ.0,
-                "SHADER_SAMPLED_READ",
+                AccessFlags2::VIDEO_DECODE_WRITE_KHR.0,
+                "VIDEO_DECODE_WRITE_KHR",
             ),
+            (AccessFlags2::RESERVED_46_EXT.0, "RESERVED_46_EXT"),
             (
-                AccessFlags2KHR::SHADER_STORAGE_READ.0,
-                "SHADER_STORAGE_READ",
+                AccessFlags2::VIDEO_ENCODE_READ_KHR.0,
+                "VIDEO_ENCODE_READ_KHR",
             ),
             (
-                AccessFlags2KHR::SHADER_STORAGE_WRITE.0,
-                "SHADER_STORAGE_WRITE",
+                AccessFlags2::VIDEO_ENCODE_WRITE_KHR.0,
+                "VIDEO_ENCODE_WRITE_KHR",
             ),
-            (AccessFlags2KHR::VIDEO_DECODE_READ.0, "VIDEO_DECODE_READ"),
-            (AccessFlags2KHR::VIDEO_DECODE_WRITE.0, "VIDEO_DECODE_WRITE"),
-            (AccessFlags2KHR::VIDEO_ENCODE_READ.0, "VIDEO_ENCODE_READ"),
-            (AccessFlags2KHR::VIDEO_ENCODE_WRITE.0, "VIDEO_ENCODE_WRITE"),
             (
-                AccessFlags2KHR::TRANSFORM_FEEDBACK_WRITE_EXT.0,
+                AccessFlags2::TRANSFORM_FEEDBACK_WRITE_EXT.0,
                 "TRANSFORM_FEEDBACK_WRITE_EXT",
             ),
             (
-                AccessFlags2KHR::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0,
+                AccessFlags2::TRANSFORM_FEEDBACK_COUNTER_READ_EXT.0,
                 "TRANSFORM_FEEDBACK_COUNTER_READ_EXT",
             ),
             (
-                AccessFlags2KHR::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0,
+                AccessFlags2::TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT.0,
                 "TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT",
             ),
             (
-                AccessFlags2KHR::CONDITIONAL_RENDERING_READ_EXT.0,
+                AccessFlags2::CONDITIONAL_RENDERING_READ_EXT.0,
                 "CONDITIONAL_RENDERING_READ_EXT",
             ),
             (
-                AccessFlags2KHR::COMMAND_PREPROCESS_READ_NV.0,
+                AccessFlags2::COMMAND_PREPROCESS_READ_NV.0,
                 "COMMAND_PREPROCESS_READ_NV",
             ),
             (
-                AccessFlags2KHR::COMMAND_PREPROCESS_WRITE_NV.0,
+                AccessFlags2::COMMAND_PREPROCESS_WRITE_NV.0,
                 "COMMAND_PREPROCESS_WRITE_NV",
             ),
             (
-                AccessFlags2KHR::FRAGMENT_SHADING_RATE_ATTACHMENT_READ.0,
-                "FRAGMENT_SHADING_RATE_ATTACHMENT_READ",
+                AccessFlags2::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR.0,
+                "FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR",
             ),
             (
-                AccessFlags2KHR::ACCELERATION_STRUCTURE_READ.0,
-                "ACCELERATION_STRUCTURE_READ",
+                AccessFlags2::ACCELERATION_STRUCTURE_READ_KHR.0,
+                "ACCELERATION_STRUCTURE_READ_KHR",
             ),
             (
-                AccessFlags2KHR::ACCELERATION_STRUCTURE_WRITE.0,
-                "ACCELERATION_STRUCTURE_WRITE",
+                AccessFlags2::ACCELERATION_STRUCTURE_WRITE_KHR.0,
+                "ACCELERATION_STRUCTURE_WRITE_KHR",
             ),
             (
-                AccessFlags2KHR::FRAGMENT_DENSITY_MAP_READ_EXT.0,
+                AccessFlags2::FRAGMENT_DENSITY_MAP_READ_EXT.0,
                 "FRAGMENT_DENSITY_MAP_READ_EXT",
             ),
             (
-                AccessFlags2KHR::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0,
+                AccessFlags2::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0,
                 "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT",
             ),
             (
-                AccessFlags2KHR::INVOCATION_MASK_READ_HUAWEI.0,
+                AccessFlags2::DESCRIPTOR_BUFFER_READ_EXT.0,
+                "DESCRIPTOR_BUFFER_READ_EXT",
+            ),
+            (
+                AccessFlags2::INVOCATION_MASK_READ_HUAWEI.0,
                 "INVOCATION_MASK_READ_HUAWEI",
             ),
+            (
+                AccessFlags2::SHADER_BINDING_TABLE_READ_KHR.0,
+                "SHADER_BINDING_TABLE_READ_KHR",
+            ),
+            (AccessFlags2::MICROMAP_READ_EXT.0, "MICROMAP_READ_EXT"),
+            (AccessFlags2::MICROMAP_WRITE_EXT.0, "MICROMAP_WRITE_EXT"),
+            (AccessFlags2::RESERVED_49_ARM.0, "RESERVED_49_ARM"),
+            (AccessFlags2::RESERVED_50_ARM.0, "RESERVED_50_ARM"),
+            (AccessFlags2::OPTICAL_FLOW_READ_NV.0, "OPTICAL_FLOW_READ_NV"),
+            (
+                AccessFlags2::OPTICAL_FLOW_WRITE_NV.0,
+                "OPTICAL_FLOW_WRITE_NV",
+            ),
+            (AccessFlags2::RESERVED_47_EXT.0, "RESERVED_47_EXT"),
+            (AccessFlags2::RESERVED_48_EXT.0, "RESERVED_48_EXT"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -368,7 +370,7 @@ impl fmt::Debug for AttachmentStoreOp {
         let name = match *self {
             Self::STORE => Some("STORE"),
             Self::DONT_CARE => Some("DONT_CARE"),
-            Self::NONE_EXT => Some("NONE_EXT"),
+            Self::NONE => Some("NONE"),
             _ => None,
         };
         if let Some(x) = name {
@@ -513,6 +515,11 @@ impl fmt::Debug for BufferCreateFlags {
             (BufferCreateFlags::SPARSE_BINDING.0, "SPARSE_BINDING"),
             (BufferCreateFlags::SPARSE_RESIDENCY.0, "SPARSE_RESIDENCY"),
             (BufferCreateFlags::SPARSE_ALIASED.0, "SPARSE_ALIASED"),
+            (
+                BufferCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
+                "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
+            ),
+            (BufferCreateFlags::RESERVED_6_KHR.0, "RESERVED_6_KHR"),
             (BufferCreateFlags::PROTECTED.0, "PROTECTED"),
             (
                 BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0,
@@ -560,6 +567,7 @@ impl fmt::Debug for BufferUsageFlags {
                 BufferUsageFlags::CONDITIONAL_RENDERING_EXT.0,
                 "CONDITIONAL_RENDERING_EXT",
             ),
+            (BufferUsageFlags::RESERVED_25_AMD.0, "RESERVED_25_AMD"),
             (
                 BufferUsageFlags::ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR.0,
                 "ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR",
@@ -582,6 +590,26 @@ impl fmt::Debug for BufferUsageFlags {
                 "VIDEO_ENCODE_SRC_KHR",
             ),
             (
+                BufferUsageFlags::SAMPLER_DESCRIPTOR_BUFFER_EXT.0,
+                "SAMPLER_DESCRIPTOR_BUFFER_EXT",
+            ),
+            (
+                BufferUsageFlags::RESOURCE_DESCRIPTOR_BUFFER_EXT.0,
+                "RESOURCE_DESCRIPTOR_BUFFER_EXT",
+            ),
+            (
+                BufferUsageFlags::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT.0,
+                "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT",
+            ),
+            (
+                BufferUsageFlags::MICROMAP_BUILD_INPUT_READ_ONLY_EXT.0,
+                "MICROMAP_BUILD_INPUT_READ_ONLY_EXT",
+            ),
+            (
+                BufferUsageFlags::MICROMAP_STORAGE_EXT.0,
+                "MICROMAP_STORAGE_EXT",
+            ),
+            (
                 BufferUsageFlags::SHADER_DEVICE_ADDRESS.0,
                 "SHADER_DEVICE_ADDRESS",
             ),
@@ -619,6 +647,26 @@ impl fmt::Debug for BuildAccelerationStructureFlagsKHR {
                 "LOW_MEMORY",
             ),
             (BuildAccelerationStructureFlagsKHR::MOTION_NV.0, "MOTION_NV"),
+            (
+                BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_UPDATE_EXT.0,
+                "ALLOW_OPACITY_MICROMAP_UPDATE_EXT",
+            ),
+            (
+                BuildAccelerationStructureFlagsKHR::ALLOW_DISABLE_OPACITY_MICROMAPS_EXT.0,
+                "ALLOW_DISABLE_OPACITY_MICROMAPS_EXT",
+            ),
+            (
+                BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT.0,
+                "ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT",
+            ),
+            (
+                BuildAccelerationStructureFlagsKHR::ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV.0,
+                "ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV",
+            ),
+            (
+                BuildAccelerationStructureFlagsKHR::ALLOW_DATA_ACCESS.0,
+                "ALLOW_DATA_ACCESS",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -637,6 +685,38 @@ impl fmt::Debug for BuildAccelerationStructureModeKHR {
         }
     }
 }
+impl fmt::Debug for BuildMicromapFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                BuildMicromapFlagsEXT::PREFER_FAST_TRACE.0,
+                "PREFER_FAST_TRACE",
+            ),
+            (
+                BuildMicromapFlagsEXT::PREFER_FAST_BUILD.0,
+                "PREFER_FAST_BUILD",
+            ),
+            (
+                BuildMicromapFlagsEXT::ALLOW_COMPACTION.0,
+                "ALLOW_COMPACTION",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for BuildMicromapModeEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::BUILD => Some("BUILD"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for ChromaLocation {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -763,10 +843,16 @@ impl fmt::Debug for CommandPoolCreateFlags {
 }
 impl fmt::Debug for CommandPoolResetFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[(
-            CommandPoolResetFlags::RELEASE_RESOURCES.0,
-            "RELEASE_RESOURCES",
-        )];
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                CommandPoolResetFlags::RELEASE_RESOURCES.0,
+                "RELEASE_RESOURCES",
+            ),
+            (
+                CommandPoolResetFlags::RESERVED_1_COREAVI.0,
+                "RESERVED_1_COREAVI",
+            ),
+        ];
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -886,6 +972,22 @@ impl fmt::Debug for CopyAccelerationStructureModeKHR {
         }
     }
 }
+impl fmt::Debug for CopyMicromapModeEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::CLONE => Some("CLONE"),
+            Self::SERIALIZE => Some("SERIALIZE"),
+            Self::DESERIALIZE => Some("DESERIALIZE"),
+            Self::COMPACT => Some("COMPACT"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for CoverageModulationModeNV {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -983,6 +1085,7 @@ impl fmt::Debug for DebugReportObjectTypeEXT {
             Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"),
             Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
             Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
+            Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"),
             _ => None,
         };
         if let Some(x) = name {
@@ -1009,6 +1112,10 @@ impl fmt::Debug for DebugUtilsMessageTypeFlagsEXT {
             (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"),
             (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"),
             (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"),
+            (
+                DebugUtilsMessageTypeFlagsEXT::DEVICE_ADDRESS_BINDING.0,
+                "DEVICE_ADDRESS_BINDING",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -1029,6 +1136,7 @@ impl fmt::Debug for DependencyFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
             (DependencyFlags::BY_REGION.0, "BY_REGION"),
+            (DependencyFlags::FEEDBACK_LOOP_EXT.0, "FEEDBACK_LOOP_EXT"),
             (DependencyFlags::DEVICE_GROUP.0, "DEVICE_GROUP"),
             (DependencyFlags::VIEW_LOCAL.0, "VIEW_LOCAL"),
         ];
@@ -1063,10 +1171,7 @@ impl fmt::Debug for DescriptorPoolCreateFlags {
                 DescriptorPoolCreateFlags::FREE_DESCRIPTOR_SET.0,
                 "FREE_DESCRIPTOR_SET",
             ),
-            (
-                DescriptorPoolCreateFlags::HOST_ONLY_VALVE.0,
-                "HOST_ONLY_VALVE",
-            ),
+            (DescriptorPoolCreateFlags::HOST_ONLY_EXT.0, "HOST_ONLY_EXT"),
             (
                 DescriptorPoolCreateFlags::UPDATE_AFTER_BIND.0,
                 "UPDATE_AFTER_BIND",
@@ -1089,12 +1194,24 @@ impl fmt::Debug for DescriptorSetLayoutCreateFlags {
                 "PUSH_DESCRIPTOR_KHR",
             ),
             (
+                DescriptorSetLayoutCreateFlags::DESCRIPTOR_BUFFER_EXT.0,
+                "DESCRIPTOR_BUFFER_EXT",
+            ),
+            (
+                DescriptorSetLayoutCreateFlags::EMBEDDED_IMMUTABLE_SAMPLERS_EXT.0,
+                "EMBEDDED_IMMUTABLE_SAMPLERS_EXT",
+            ),
+            (
                 DescriptorSetLayoutCreateFlags::RESERVED_3_AMD.0,
                 "RESERVED_3_AMD",
             ),
             (
-                DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_VALVE.0,
-                "HOST_ONLY_POOL_VALVE",
+                DescriptorSetLayoutCreateFlags::HOST_ONLY_POOL_EXT.0,
+                "HOST_ONLY_POOL_EXT",
+            ),
+            (
+                DescriptorSetLayoutCreateFlags::RESERVED_6_EXT.0,
+                "RESERVED_6_EXT",
             ),
             (
                 DescriptorSetLayoutCreateFlags::UPDATE_AFTER_BIND_POOL.0,
@@ -1118,10 +1235,12 @@ impl fmt::Debug for DescriptorType {
             Self::UNIFORM_BUFFER_DYNAMIC => Some("UNIFORM_BUFFER_DYNAMIC"),
             Self::STORAGE_BUFFER_DYNAMIC => Some("STORAGE_BUFFER_DYNAMIC"),
             Self::INPUT_ATTACHMENT => Some("INPUT_ATTACHMENT"),
-            Self::INLINE_UNIFORM_BLOCK_EXT => Some("INLINE_UNIFORM_BLOCK_EXT"),
             Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
             Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
-            Self::MUTABLE_VALVE => Some("MUTABLE_VALVE"),
+            Self::SAMPLE_WEIGHT_IMAGE_QCOM => Some("SAMPLE_WEIGHT_IMAGE_QCOM"),
+            Self::BLOCK_MATCH_IMAGE_QCOM => Some("BLOCK_MATCH_IMAGE_QCOM"),
+            Self::MUTABLE_EXT => Some("MUTABLE_EXT"),
+            Self::INLINE_UNIFORM_BLOCK => Some("INLINE_UNIFORM_BLOCK"),
             _ => None,
         };
         if let Some(x) = name {
@@ -1151,6 +1270,29 @@ impl fmt::Debug for DescriptorUpdateTemplateType {
         }
     }
 }
+impl fmt::Debug for DeviceAddressBindingFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[(
+            DeviceAddressBindingFlagsEXT::INTERNAL_OBJECT.0,
+            "INTERNAL_OBJECT",
+        )];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for DeviceAddressBindingTypeEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::BIND => Some("BIND"),
+            Self::UNBIND => Some("UNBIND"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for DeviceCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[];
@@ -1172,6 +1314,10 @@ impl fmt::Debug for DeviceDiagnosticsConfigFlagsNV {
                 DeviceDiagnosticsConfigFlagsNV::ENABLE_AUTOMATIC_CHECKPOINTS.0,
                 "ENABLE_AUTOMATIC_CHECKPOINTS",
             ),
+            (
+                DeviceDiagnosticsConfigFlagsNV::ENABLE_SHADER_ERROR_REPORTING.0,
+                "ENABLE_SHADER_ERROR_REPORTING",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -1189,6 +1335,38 @@ impl fmt::Debug for DeviceEventTypeEXT {
         }
     }
 }
+impl fmt::Debug for DeviceFaultAddressTypeEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::NONE => Some("NONE"),
+            Self::READ_INVALID => Some("READ_INVALID"),
+            Self::WRITE_INVALID => Some("WRITE_INVALID"),
+            Self::EXECUTE_INVALID => Some("EXECUTE_INVALID"),
+            Self::INSTRUCTION_POINTER_UNKNOWN => Some("INSTRUCTION_POINTER_UNKNOWN"),
+            Self::INSTRUCTION_POINTER_INVALID => Some("INSTRUCTION_POINTER_INVALID"),
+            Self::INSTRUCTION_POINTER_FAULT => Some("INSTRUCTION_POINTER_FAULT"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for DeviceFaultVendorBinaryHeaderVersionEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::ONE => Some("ONE"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for DeviceGroupPresentModeFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
@@ -1228,10 +1406,33 @@ impl fmt::Debug for DeviceMemoryReportFlagsEXT {
 }
 impl fmt::Debug for DeviceQueueCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[(DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED")];
+        const KNOWN: &[(Flags, &str)] = &[
+            (DeviceQueueCreateFlags::RESERVED_1_QCOM.0, "RESERVED_1_QCOM"),
+            (DeviceQueueCreateFlags::PROTECTED.0, "PROTECTED"),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for DirectDriverLoadingFlagsLUNARG {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[];
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for DirectDriverLoadingModeLUNARG {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::EXCLUSIVE => Some("EXCLUSIVE"),
+            Self::INCLUSIVE => Some("INCLUSIVE"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for DirectFBSurfaceCreateFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[];
@@ -1252,6 +1453,21 @@ impl fmt::Debug for DiscardRectangleModeEXT {
         }
     }
 }
+impl fmt::Debug for DisplacementMicromapFormatNV {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::TYPE_64_TRIANGLES_64_BYTES => Some("TYPE_64_TRIANGLES_64_BYTES"),
+            Self::TYPE_256_TRIANGLES_128_BYTES => Some("TYPE_256_TRIANGLES_128_BYTES"),
+            Self::TYPE_1024_TRIANGLES_128_BYTES => Some("TYPE_1024_TRIANGLES_128_BYTES"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for DisplayEventTypeEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -1326,6 +1542,14 @@ impl fmt::Debug for DriverId {
             Self::COREAVI_PROPRIETARY => Some("COREAVI_PROPRIETARY"),
             Self::JUICE_PROPRIETARY => Some("JUICE_PROPRIETARY"),
             Self::VERISILICON_PROPRIETARY => Some("VERISILICON_PROPRIETARY"),
+            Self::MESA_TURNIP => Some("MESA_TURNIP"),
+            Self::MESA_V3DV => Some("MESA_V3DV"),
+            Self::MESA_PANVK => Some("MESA_PANVK"),
+            Self::SAMSUNG_PROPRIETARY => Some("SAMSUNG_PROPRIETARY"),
+            Self::MESA_VENUS => Some("MESA_VENUS"),
+            Self::MESA_DOZEN => Some("MESA_DOZEN"),
+            Self::MESA_NVK => Some("MESA_NVK"),
+            Self::IMAGINATION_OPEN_SOURCE_MESA => Some("IMAGINATION_OPEN_SOURCE_MESA"),
             _ => None,
         };
         if let Some(x) = name {
@@ -1349,34 +1573,79 @@ impl fmt::Debug for DynamicState {
             Self::STENCIL_REFERENCE => Some("STENCIL_REFERENCE"),
             Self::VIEWPORT_W_SCALING_NV => Some("VIEWPORT_W_SCALING_NV"),
             Self::DISCARD_RECTANGLE_EXT => Some("DISCARD_RECTANGLE_EXT"),
+            Self::DISCARD_RECTANGLE_ENABLE_EXT => Some("DISCARD_RECTANGLE_ENABLE_EXT"),
+            Self::DISCARD_RECTANGLE_MODE_EXT => Some("DISCARD_RECTANGLE_MODE_EXT"),
             Self::SAMPLE_LOCATIONS_EXT => Some("SAMPLE_LOCATIONS_EXT"),
             Self::RAY_TRACING_PIPELINE_STACK_SIZE_KHR => {
                 Some("RAY_TRACING_PIPELINE_STACK_SIZE_KHR")
             }
             Self::VIEWPORT_SHADING_RATE_PALETTE_NV => Some("VIEWPORT_SHADING_RATE_PALETTE_NV"),
             Self::VIEWPORT_COARSE_SAMPLE_ORDER_NV => Some("VIEWPORT_COARSE_SAMPLE_ORDER_NV"),
+            Self::EXCLUSIVE_SCISSOR_ENABLE_NV => Some("EXCLUSIVE_SCISSOR_ENABLE_NV"),
             Self::EXCLUSIVE_SCISSOR_NV => Some("EXCLUSIVE_SCISSOR_NV"),
             Self::FRAGMENT_SHADING_RATE_KHR => Some("FRAGMENT_SHADING_RATE_KHR"),
             Self::LINE_STIPPLE_EXT => Some("LINE_STIPPLE_EXT"),
-            Self::CULL_MODE_EXT => Some("CULL_MODE_EXT"),
-            Self::FRONT_FACE_EXT => Some("FRONT_FACE_EXT"),
-            Self::PRIMITIVE_TOPOLOGY_EXT => Some("PRIMITIVE_TOPOLOGY_EXT"),
-            Self::VIEWPORT_WITH_COUNT_EXT => Some("VIEWPORT_WITH_COUNT_EXT"),
-            Self::SCISSOR_WITH_COUNT_EXT => Some("SCISSOR_WITH_COUNT_EXT"),
-            Self::VERTEX_INPUT_BINDING_STRIDE_EXT => Some("VERTEX_INPUT_BINDING_STRIDE_EXT"),
-            Self::DEPTH_TEST_ENABLE_EXT => Some("DEPTH_TEST_ENABLE_EXT"),
-            Self::DEPTH_WRITE_ENABLE_EXT => Some("DEPTH_WRITE_ENABLE_EXT"),
-            Self::DEPTH_COMPARE_OP_EXT => Some("DEPTH_COMPARE_OP_EXT"),
-            Self::DEPTH_BOUNDS_TEST_ENABLE_EXT => Some("DEPTH_BOUNDS_TEST_ENABLE_EXT"),
-            Self::STENCIL_TEST_ENABLE_EXT => Some("STENCIL_TEST_ENABLE_EXT"),
-            Self::STENCIL_OP_EXT => Some("STENCIL_OP_EXT"),
             Self::VERTEX_INPUT_EXT => Some("VERTEX_INPUT_EXT"),
             Self::PATCH_CONTROL_POINTS_EXT => Some("PATCH_CONTROL_POINTS_EXT"),
-            Self::RASTERIZER_DISCARD_ENABLE_EXT => Some("RASTERIZER_DISCARD_ENABLE_EXT"),
-            Self::DEPTH_BIAS_ENABLE_EXT => Some("DEPTH_BIAS_ENABLE_EXT"),
             Self::LOGIC_OP_EXT => Some("LOGIC_OP_EXT"),
-            Self::PRIMITIVE_RESTART_ENABLE_EXT => Some("PRIMITIVE_RESTART_ENABLE_EXT"),
             Self::COLOR_WRITE_ENABLE_EXT => Some("COLOR_WRITE_ENABLE_EXT"),
+            Self::TESSELLATION_DOMAIN_ORIGIN_EXT => Some("TESSELLATION_DOMAIN_ORIGIN_EXT"),
+            Self::DEPTH_CLAMP_ENABLE_EXT => Some("DEPTH_CLAMP_ENABLE_EXT"),
+            Self::POLYGON_MODE_EXT => Some("POLYGON_MODE_EXT"),
+            Self::RASTERIZATION_SAMPLES_EXT => Some("RASTERIZATION_SAMPLES_EXT"),
+            Self::SAMPLE_MASK_EXT => Some("SAMPLE_MASK_EXT"),
+            Self::ALPHA_TO_COVERAGE_ENABLE_EXT => Some("ALPHA_TO_COVERAGE_ENABLE_EXT"),
+            Self::ALPHA_TO_ONE_ENABLE_EXT => Some("ALPHA_TO_ONE_ENABLE_EXT"),
+            Self::LOGIC_OP_ENABLE_EXT => Some("LOGIC_OP_ENABLE_EXT"),
+            Self::COLOR_BLEND_ENABLE_EXT => Some("COLOR_BLEND_ENABLE_EXT"),
+            Self::COLOR_BLEND_EQUATION_EXT => Some("COLOR_BLEND_EQUATION_EXT"),
+            Self::COLOR_WRITE_MASK_EXT => Some("COLOR_WRITE_MASK_EXT"),
+            Self::RASTERIZATION_STREAM_EXT => Some("RASTERIZATION_STREAM_EXT"),
+            Self::CONSERVATIVE_RASTERIZATION_MODE_EXT => {
+                Some("CONSERVATIVE_RASTERIZATION_MODE_EXT")
+            }
+            Self::EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT => {
+                Some("EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT")
+            }
+            Self::DEPTH_CLIP_ENABLE_EXT => Some("DEPTH_CLIP_ENABLE_EXT"),
+            Self::SAMPLE_LOCATIONS_ENABLE_EXT => Some("SAMPLE_LOCATIONS_ENABLE_EXT"),
+            Self::COLOR_BLEND_ADVANCED_EXT => Some("COLOR_BLEND_ADVANCED_EXT"),
+            Self::PROVOKING_VERTEX_MODE_EXT => Some("PROVOKING_VERTEX_MODE_EXT"),
+            Self::LINE_RASTERIZATION_MODE_EXT => Some("LINE_RASTERIZATION_MODE_EXT"),
+            Self::LINE_STIPPLE_ENABLE_EXT => Some("LINE_STIPPLE_ENABLE_EXT"),
+            Self::DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT => Some("DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT"),
+            Self::VIEWPORT_W_SCALING_ENABLE_NV => Some("VIEWPORT_W_SCALING_ENABLE_NV"),
+            Self::VIEWPORT_SWIZZLE_NV => Some("VIEWPORT_SWIZZLE_NV"),
+            Self::COVERAGE_TO_COLOR_ENABLE_NV => Some("COVERAGE_TO_COLOR_ENABLE_NV"),
+            Self::COVERAGE_TO_COLOR_LOCATION_NV => Some("COVERAGE_TO_COLOR_LOCATION_NV"),
+            Self::COVERAGE_MODULATION_MODE_NV => Some("COVERAGE_MODULATION_MODE_NV"),
+            Self::COVERAGE_MODULATION_TABLE_ENABLE_NV => {
+                Some("COVERAGE_MODULATION_TABLE_ENABLE_NV")
+            }
+            Self::COVERAGE_MODULATION_TABLE_NV => Some("COVERAGE_MODULATION_TABLE_NV"),
+            Self::SHADING_RATE_IMAGE_ENABLE_NV => Some("SHADING_RATE_IMAGE_ENABLE_NV"),
+            Self::REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV => {
+                Some("REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV")
+            }
+            Self::COVERAGE_REDUCTION_MODE_NV => Some("COVERAGE_REDUCTION_MODE_NV"),
+            Self::ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT => {
+                Some("ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT")
+            }
+            Self::CULL_MODE => Some("CULL_MODE"),
+            Self::FRONT_FACE => Some("FRONT_FACE"),
+            Self::PRIMITIVE_TOPOLOGY => Some("PRIMITIVE_TOPOLOGY"),
+            Self::VIEWPORT_WITH_COUNT => Some("VIEWPORT_WITH_COUNT"),
+            Self::SCISSOR_WITH_COUNT => Some("SCISSOR_WITH_COUNT"),
+            Self::VERTEX_INPUT_BINDING_STRIDE => Some("VERTEX_INPUT_BINDING_STRIDE"),
+            Self::DEPTH_TEST_ENABLE => Some("DEPTH_TEST_ENABLE"),
+            Self::DEPTH_WRITE_ENABLE => Some("DEPTH_WRITE_ENABLE"),
+            Self::DEPTH_COMPARE_OP => Some("DEPTH_COMPARE_OP"),
+            Self::DEPTH_BOUNDS_TEST_ENABLE => Some("DEPTH_BOUNDS_TEST_ENABLE"),
+            Self::STENCIL_TEST_ENABLE => Some("STENCIL_TEST_ENABLE"),
+            Self::STENCIL_OP => Some("STENCIL_OP"),
+            Self::RASTERIZER_DISCARD_ENABLE => Some("RASTERIZER_DISCARD_ENABLE"),
+            Self::DEPTH_BIAS_ENABLE => Some("DEPTH_BIAS_ENABLE"),
+            Self::PRIMITIVE_RESTART_ENABLE => Some("PRIMITIVE_RESTART_ENABLE"),
             _ => None,
         };
         if let Some(x) = name {
@@ -1388,7 +1657,38 @@ impl fmt::Debug for DynamicState {
 }
 impl fmt::Debug for EventCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[(EventCreateFlags::DEVICE_ONLY_KHR.0, "DEVICE_ONLY_KHR")];
+        const KNOWN: &[(Flags, &str)] = &[(EventCreateFlags::DEVICE_ONLY.0, "DEVICE_ONLY")];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for ExportMetalObjectTypeFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                ExportMetalObjectTypeFlagsEXT::METAL_DEVICE.0,
+                "METAL_DEVICE",
+            ),
+            (
+                ExportMetalObjectTypeFlagsEXT::METAL_COMMAND_QUEUE.0,
+                "METAL_COMMAND_QUEUE",
+            ),
+            (
+                ExportMetalObjectTypeFlagsEXT::METAL_BUFFER.0,
+                "METAL_BUFFER",
+            ),
+            (
+                ExportMetalObjectTypeFlagsEXT::METAL_TEXTURE.0,
+                "METAL_TEXTURE",
+            ),
+            (
+                ExportMetalObjectTypeFlagsEXT::METAL_IOSURFACE.0,
+                "METAL_IOSURFACE",
+            ),
+            (
+                ExportMetalObjectTypeFlagsEXT::METAL_SHARED_EVENT.0,
+                "METAL_SHARED_EVENT",
+            ),
+        ];
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -1411,14 +1711,6 @@ impl fmt::Debug for ExternalFenceHandleTypeFlags {
                 "OPAQUE_WIN32_KMT",
             ),
             (ExternalFenceHandleTypeFlags::SYNC_FD.0, "SYNC_FD"),
-            (
-                ExternalFenceHandleTypeFlags::RESERVED_4_NV.0,
-                "RESERVED_4_NV",
-            ),
-            (
-                ExternalFenceHandleTypeFlags::RESERVED_5_NV.0,
-                "RESERVED_5_NV",
-            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -1496,8 +1788,8 @@ impl fmt::Debug for ExternalMemoryHandleTypeFlags {
                 "RDMA_ADDRESS_NV",
             ),
             (
-                ExternalMemoryHandleTypeFlags::RESERVED_13_NV.0,
-                "RESERVED_13_NV",
+                ExternalMemoryHandleTypeFlags::TYPE_530_QNX.0,
+                "TYPE_530_QNX",
             ),
         ];
         debug_flags(f, KNOWN, self.0)
@@ -1556,14 +1848,6 @@ impl fmt::Debug for ExternalSemaphoreHandleTypeFlags {
                 ExternalSemaphoreHandleTypeFlags::ZIRCON_EVENT_FUCHSIA.0,
                 "ZIRCON_EVENT_FUCHSIA",
             ),
-            (
-                ExternalSemaphoreHandleTypeFlags::RESERVED_5_NV.0,
-                "RESERVED_5_NV",
-            ),
-            (
-                ExternalSemaphoreHandleTypeFlags::RESERVED_6_NV.0,
-                "RESERVED_6_NV",
-            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -1585,7 +1869,7 @@ impl fmt::Debug for Filter {
         let name = match *self {
             Self::NEAREST => Some("NEAREST"),
             Self::LINEAR => Some("LINEAR"),
-            Self::CUBIC_IMG => Some("CUBIC_IMG"),
+            Self::CUBIC_EXT => Some("CUBIC_EXT"),
             _ => None,
         };
         if let Some(x) = name {
@@ -1791,20 +2075,6 @@ impl fmt::Debug for Format {
             Self::PVRTC1_4BPP_SRGB_BLOCK_IMG => Some("PVRTC1_4BPP_SRGB_BLOCK_IMG"),
             Self::PVRTC2_2BPP_SRGB_BLOCK_IMG => Some("PVRTC2_2BPP_SRGB_BLOCK_IMG"),
             Self::PVRTC2_4BPP_SRGB_BLOCK_IMG => Some("PVRTC2_4BPP_SRGB_BLOCK_IMG"),
-            Self::ASTC_4X4_SFLOAT_BLOCK_EXT => Some("ASTC_4X4_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_5X4_SFLOAT_BLOCK_EXT => Some("ASTC_5X4_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_5X5_SFLOAT_BLOCK_EXT => Some("ASTC_5X5_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_6X5_SFLOAT_BLOCK_EXT => Some("ASTC_6X5_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_6X6_SFLOAT_BLOCK_EXT => Some("ASTC_6X6_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_8X5_SFLOAT_BLOCK_EXT => Some("ASTC_8X5_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_8X6_SFLOAT_BLOCK_EXT => Some("ASTC_8X6_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_8X8_SFLOAT_BLOCK_EXT => Some("ASTC_8X8_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_10X5_SFLOAT_BLOCK_EXT => Some("ASTC_10X5_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_10X6_SFLOAT_BLOCK_EXT => Some("ASTC_10X6_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_10X8_SFLOAT_BLOCK_EXT => Some("ASTC_10X8_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_10X10_SFLOAT_BLOCK_EXT => Some("ASTC_10X10_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_12X10_SFLOAT_BLOCK_EXT => Some("ASTC_12X10_SFLOAT_BLOCK_EXT"),
-            Self::ASTC_12X12_SFLOAT_BLOCK_EXT => Some("ASTC_12X12_SFLOAT_BLOCK_EXT"),
             Self::ASTC_3X3X3_UNORM_BLOCK_EXT => Some("ASTC_3X3X3_UNORM_BLOCK_EXT"),
             Self::ASTC_3X3X3_SRGB_BLOCK_EXT => Some("ASTC_3X3X3_SRGB_BLOCK_EXT"),
             Self::ASTC_3X3X3_SFLOAT_BLOCK_EXT => Some("ASTC_3X3X3_SFLOAT_BLOCK_EXT"),
@@ -1835,16 +2105,7 @@ impl fmt::Debug for Format {
             Self::ASTC_6X6X6_UNORM_BLOCK_EXT => Some("ASTC_6X6X6_UNORM_BLOCK_EXT"),
             Self::ASTC_6X6X6_SRGB_BLOCK_EXT => Some("ASTC_6X6X6_SRGB_BLOCK_EXT"),
             Self::ASTC_6X6X6_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X6_SFLOAT_BLOCK_EXT"),
-            Self::G8_B8R8_2PLANE_444_UNORM_EXT => Some("G8_B8R8_2PLANE_444_UNORM_EXT"),
-            Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT => {
-                Some("G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT")
-            }
-            Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT => {
-                Some("G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT")
-            }
-            Self::G16_B16R16_2PLANE_444_UNORM_EXT => Some("G16_B16R16_2PLANE_444_UNORM_EXT"),
-            Self::A4R4G4B4_UNORM_PACK16_EXT => Some("A4R4G4B4_UNORM_PACK16_EXT"),
-            Self::A4B4G4R4_UNORM_PACK16_EXT => Some("A4B4G4R4_UNORM_PACK16_EXT"),
+            Self::R16G16_S10_5_NV => Some("R16G16_S10_5_NV"),
             Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"),
             Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"),
             Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"),
@@ -1907,6 +2168,30 @@ impl fmt::Debug for Format {
             Self::G16_B16_R16_3PLANE_422_UNORM => Some("G16_B16_R16_3PLANE_422_UNORM"),
             Self::G16_B16R16_2PLANE_422_UNORM => Some("G16_B16R16_2PLANE_422_UNORM"),
             Self::G16_B16_R16_3PLANE_444_UNORM => Some("G16_B16_R16_3PLANE_444_UNORM"),
+            Self::G8_B8R8_2PLANE_444_UNORM => Some("G8_B8R8_2PLANE_444_UNORM"),
+            Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 => {
+                Some("G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16")
+            }
+            Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 => {
+                Some("G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16")
+            }
+            Self::G16_B16R16_2PLANE_444_UNORM => Some("G16_B16R16_2PLANE_444_UNORM"),
+            Self::A4R4G4B4_UNORM_PACK16 => Some("A4R4G4B4_UNORM_PACK16"),
+            Self::A4B4G4R4_UNORM_PACK16 => Some("A4B4G4R4_UNORM_PACK16"),
+            Self::ASTC_4X4_SFLOAT_BLOCK => Some("ASTC_4X4_SFLOAT_BLOCK"),
+            Self::ASTC_5X4_SFLOAT_BLOCK => Some("ASTC_5X4_SFLOAT_BLOCK"),
+            Self::ASTC_5X5_SFLOAT_BLOCK => Some("ASTC_5X5_SFLOAT_BLOCK"),
+            Self::ASTC_6X5_SFLOAT_BLOCK => Some("ASTC_6X5_SFLOAT_BLOCK"),
+            Self::ASTC_6X6_SFLOAT_BLOCK => Some("ASTC_6X6_SFLOAT_BLOCK"),
+            Self::ASTC_8X5_SFLOAT_BLOCK => Some("ASTC_8X5_SFLOAT_BLOCK"),
+            Self::ASTC_8X6_SFLOAT_BLOCK => Some("ASTC_8X6_SFLOAT_BLOCK"),
+            Self::ASTC_8X8_SFLOAT_BLOCK => Some("ASTC_8X8_SFLOAT_BLOCK"),
+            Self::ASTC_10X5_SFLOAT_BLOCK => Some("ASTC_10X5_SFLOAT_BLOCK"),
+            Self::ASTC_10X6_SFLOAT_BLOCK => Some("ASTC_10X6_SFLOAT_BLOCK"),
+            Self::ASTC_10X8_SFLOAT_BLOCK => Some("ASTC_10X8_SFLOAT_BLOCK"),
+            Self::ASTC_10X10_SFLOAT_BLOCK => Some("ASTC_10X10_SFLOAT_BLOCK"),
+            Self::ASTC_12X10_SFLOAT_BLOCK => Some("ASTC_12X10_SFLOAT_BLOCK"),
+            Self::ASTC_12X12_SFLOAT_BLOCK => Some("ASTC_12X12_SFLOAT_BLOCK"),
             _ => None,
         };
         if let Some(x) = name {
@@ -1918,7 +2203,13 @@ impl fmt::Debug for Format {
 }
 impl fmt::Debug for FormatFeatureFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN : & [(Flags , & str)] = & [(FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_IMG . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_IMG") , (FormatFeatureFlags :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX")] ;
+        const KNOWN : & [(Flags , & str)] = & [(FormatFeatureFlags :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_CUBIC_EXT . 0 , "SAMPLED_IMAGE_FILTER_CUBIC_EXT") , (FormatFeatureFlags :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX")] ;
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for FormatFeatureFlags2 {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: RESERVED_44_EXT . 0 , "RESERVED_44_EXT") , (FormatFeatureFlags2 :: RESERVED_45_EXT . 0 , "RESERVED_45_EXT") , (FormatFeatureFlags2 :: RESERVED_46_EXT . 0 , "RESERVED_46_EXT") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: RESERVED_39_EXT . 0 , "RESERVED_39_EXT") , (FormatFeatureFlags2 :: OPTICAL_FLOW_IMAGE_NV . 0 , "OPTICAL_FLOW_IMAGE_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_VECTOR_NV . 0 , "OPTICAL_FLOW_VECTOR_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_COST_NV . 0 , "OPTICAL_FLOW_COST_NV")] ;
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -2041,6 +2332,14 @@ impl fmt::Debug for GeometryInstanceFlagsKHR {
                 GeometryInstanceFlagsKHR::FORCE_NO_OPAQUE.0,
                 "FORCE_NO_OPAQUE",
             ),
+            (
+                GeometryInstanceFlagsKHR::FORCE_OPACITY_MICROMAP_2_STATE_EXT.0,
+                "FORCE_OPACITY_MICROMAP_2_STATE_EXT",
+            ),
+            (
+                GeometryInstanceFlagsKHR::DISABLE_OPACITY_MICROMAPS_EXT.0,
+                "DISABLE_OPACITY_MICROMAPS_EXT",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -2060,6 +2359,29 @@ impl fmt::Debug for GeometryTypeKHR {
         }
     }
 }
+impl fmt::Debug for GraphicsPipelineLibraryFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                GraphicsPipelineLibraryFlagsEXT::VERTEX_INPUT_INTERFACE.0,
+                "VERTEX_INPUT_INTERFACE",
+            ),
+            (
+                GraphicsPipelineLibraryFlagsEXT::PRE_RASTERIZATION_SHADERS.0,
+                "PRE_RASTERIZATION_SHADERS",
+            ),
+            (
+                GraphicsPipelineLibraryFlagsEXT::FRAGMENT_SHADER.0,
+                "FRAGMENT_SHADER",
+            ),
+            (
+                GraphicsPipelineLibraryFlagsEXT::FRAGMENT_OUTPUT_INTERFACE.0,
+                "FRAGMENT_OUTPUT_INTERFACE",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for HeadlessSurfaceCreateFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[];
@@ -2086,6 +2408,128 @@ impl fmt::Debug for ImageAspectFlags {
             (ImageAspectFlags::PLANE_0.0, "PLANE_0"),
             (ImageAspectFlags::PLANE_1.0, "PLANE_1"),
             (ImageAspectFlags::PLANE_2.0, "PLANE_2"),
+            (ImageAspectFlags::NONE.0, "NONE"),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for ImageCompressionFixedRateFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (ImageCompressionFixedRateFlagsEXT::NONE.0, "NONE"),
+            (ImageCompressionFixedRateFlagsEXT::TYPE_1BPC.0, "TYPE_1BPC"),
+            (ImageCompressionFixedRateFlagsEXT::TYPE_2BPC.0, "TYPE_2BPC"),
+            (ImageCompressionFixedRateFlagsEXT::TYPE_3BPC.0, "TYPE_3BPC"),
+            (ImageCompressionFixedRateFlagsEXT::TYPE_4BPC.0, "TYPE_4BPC"),
+            (ImageCompressionFixedRateFlagsEXT::TYPE_5BPC.0, "TYPE_5BPC"),
+            (ImageCompressionFixedRateFlagsEXT::TYPE_6BPC.0, "TYPE_6BPC"),
+            (ImageCompressionFixedRateFlagsEXT::TYPE_7BPC.0, "TYPE_7BPC"),
+            (ImageCompressionFixedRateFlagsEXT::TYPE_8BPC.0, "TYPE_8BPC"),
+            (ImageCompressionFixedRateFlagsEXT::TYPE_9BPC.0, "TYPE_9BPC"),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_10BPC.0,
+                "TYPE_10BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_11BPC.0,
+                "TYPE_11BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_12BPC.0,
+                "TYPE_12BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_13BPC.0,
+                "TYPE_13BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_14BPC.0,
+                "TYPE_14BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_15BPC.0,
+                "TYPE_15BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_16BPC.0,
+                "TYPE_16BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_17BPC.0,
+                "TYPE_17BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_18BPC.0,
+                "TYPE_18BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_19BPC.0,
+                "TYPE_19BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_20BPC.0,
+                "TYPE_20BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_21BPC.0,
+                "TYPE_21BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_22BPC.0,
+                "TYPE_22BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_23BPC.0,
+                "TYPE_23BPC",
+            ),
+            (
+                ImageCompressionFixedRateFlagsEXT::TYPE_24BPC.0,
+                "TYPE_24BPC",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for ImageCompressionFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (ImageCompressionFlagsEXT::DEFAULT.0, "DEFAULT"),
+            (
+                ImageCompressionFlagsEXT::FIXED_RATE_DEFAULT.0,
+                "FIXED_RATE_DEFAULT",
+            ),
+            (
+                ImageCompressionFlagsEXT::FIXED_RATE_EXPLICIT.0,
+                "FIXED_RATE_EXPLICIT",
+            ),
+            (ImageCompressionFlagsEXT::DISABLED.0, "DISABLED"),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for ImageConstraintsInfoFlagsFUCHSIA {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_RARELY.0,
+                "CPU_READ_RARELY",
+            ),
+            (
+                ImageConstraintsInfoFlagsFUCHSIA::CPU_READ_OFTEN.0,
+                "CPU_READ_OFTEN",
+            ),
+            (
+                ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_RARELY.0,
+                "CPU_WRITE_RARELY",
+            ),
+            (
+                ImageConstraintsInfoFlagsFUCHSIA::CPU_WRITE_OFTEN.0,
+                "CPU_WRITE_OFTEN",
+            ),
+            (
+                ImageConstraintsInfoFlagsFUCHSIA::PROTECTED_OPTIONAL.0,
+                "PROTECTED_OPTIONAL",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -2104,6 +2548,24 @@ impl fmt::Debug for ImageCreateFlags {
                 "SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT",
             ),
             (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"),
+            (ImageCreateFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"),
+            (
+                ImageCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
+                "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
+            ),
+            (
+                ImageCreateFlags::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT.0,
+                "MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT",
+            ),
+            (
+                ImageCreateFlags::TYPE_2D_VIEW_COMPATIBLE_EXT.0,
+                "TYPE_2D_VIEW_COMPATIBLE_EXT",
+            ),
+            (
+                ImageCreateFlags::FRAGMENT_DENSITY_MAP_OFFSET_QCOM.0,
+                "FRAGMENT_DENSITY_MAP_OFFSET_QCOM",
+            ),
+            (ImageCreateFlags::RESERVED_20_KHR.0, "RESERVED_20_KHR"),
             (ImageCreateFlags::ALIAS.0, "ALIAS"),
             (
                 ImageCreateFlags::SPLIT_INSTANCE_BIND_REGIONS.0,
@@ -2124,6 +2586,12 @@ impl fmt::Debug for ImageCreateFlags {
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for ImageFormatConstraintsFlagsFUCHSIA {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for ImageLayout {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -2148,8 +2616,9 @@ impl fmt::Debug for ImageLayout {
             Self::VIDEO_ENCODE_DST_KHR => Some("VIDEO_ENCODE_DST_KHR"),
             Self::VIDEO_ENCODE_SRC_KHR => Some("VIDEO_ENCODE_SRC_KHR"),
             Self::VIDEO_ENCODE_DPB_KHR => Some("VIDEO_ENCODE_DPB_KHR"),
-            Self::READ_ONLY_OPTIMAL_KHR => Some("READ_ONLY_OPTIMAL_KHR"),
-            Self::ATTACHMENT_OPTIMAL_KHR => Some("ATTACHMENT_OPTIMAL_KHR"),
+            Self::ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT => {
+                Some("ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT")
+            }
             Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL => {
                 Some("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL")
             }
@@ -2160,6 +2629,8 @@ impl fmt::Debug for ImageLayout {
             Self::DEPTH_READ_ONLY_OPTIMAL => Some("DEPTH_READ_ONLY_OPTIMAL"),
             Self::STENCIL_ATTACHMENT_OPTIMAL => Some("STENCIL_ATTACHMENT_OPTIMAL"),
             Self::STENCIL_READ_ONLY_OPTIMAL => Some("STENCIL_READ_ONLY_OPTIMAL"),
+            Self::READ_ONLY_OPTIMAL => Some("READ_ONLY_OPTIMAL"),
+            Self::ATTACHMENT_OPTIMAL => Some("ATTACHMENT_OPTIMAL"),
             _ => None,
         };
         if let Some(x) = name {
@@ -2244,6 +2715,7 @@ impl fmt::Debug for ImageUsageFlags {
                 ImageUsageFlags::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0,
                 "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR",
             ),
+            (ImageUsageFlags::RESERVED_22_EXT.0, "RESERVED_22_EXT"),
             (
                 ImageUsageFlags::VIDEO_ENCODE_DST_KHR.0,
                 "VIDEO_ENCODE_DST_KHR",
@@ -2256,11 +2728,20 @@ impl fmt::Debug for ImageUsageFlags {
                 ImageUsageFlags::VIDEO_ENCODE_DPB_KHR.0,
                 "VIDEO_ENCODE_DPB_KHR",
             ),
-            (ImageUsageFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"),
+            (
+                ImageUsageFlags::ATTACHMENT_FEEDBACK_LOOP_EXT.0,
+                "ATTACHMENT_FEEDBACK_LOOP_EXT",
+            ),
             (
                 ImageUsageFlags::INVOCATION_MASK_HUAWEI.0,
                 "INVOCATION_MASK_HUAWEI",
             ),
+            (ImageUsageFlags::SAMPLE_WEIGHT_QCOM.0, "SAMPLE_WEIGHT_QCOM"),
+            (
+                ImageUsageFlags::SAMPLE_BLOCK_MATCH_QCOM.0,
+                "SAMPLE_BLOCK_MATCH_QCOM",
+            ),
+            (ImageUsageFlags::RESERVED_23_EXT.0, "RESERVED_23_EXT"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -2273,6 +2754,10 @@ impl fmt::Debug for ImageViewCreateFlags {
                 "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT",
             ),
             (
+                ImageViewCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
+                "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
+            ),
+            (
                 ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0,
                 "FRAGMENT_DENSITY_MAP_DEFERRED_EXT",
             ),
@@ -2345,6 +2830,7 @@ impl fmt::Debug for IndirectCommandsTokenTypeNV {
             Self::DRAW_INDEXED => Some("DRAW_INDEXED"),
             Self::DRAW => Some("DRAW"),
             Self::DRAW_TASKS => Some("DRAW_TASKS"),
+            Self::DRAW_MESH_TASKS => Some("DRAW_MESH_TASKS"),
             _ => None,
         };
         if let Some(x) = name {
@@ -2363,7 +2849,10 @@ impl fmt::Debug for IndirectStateFlagsNV {
 }
 impl fmt::Debug for InstanceCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[];
+        const KNOWN: &[(Flags, &str)] = &[(
+            InstanceCreateFlags::ENUMERATE_PORTABILITY_KHR.0,
+            "ENUMERATE_PORTABILITY_KHR",
+        )];
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -2443,11 +2932,19 @@ impl fmt::Debug for MemoryAllocateFlags {
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for MemoryDecompressionMethodFlagsNV {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags64, &str)] = &[(
+            MemoryDecompressionMethodFlagsNV::GDEFLATE_1_0.0,
+            "GDEFLATE_1_0",
+        )];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for MemoryHeapFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
             (MemoryHeapFlags::DEVICE_LOCAL.0, "DEVICE_LOCAL"),
-            (MemoryHeapFlags::RESERVED_2_KHR.0, "RESERVED_2_KHR"),
             (MemoryHeapFlags::MULTI_INSTANCE.0, "MULTI_INSTANCE"),
         ];
         debug_flags(f, KNOWN, self.0)
@@ -2496,60 +2993,120 @@ impl fmt::Debug for MemoryPropertyFlags {
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for MemoryUnmapFlagsKHR {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for MetalSurfaceCreateFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for ObjectType {
+impl fmt::Debug for MicromapCreateFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[(
+            MicromapCreateFlagsEXT::DEVICE_ADDRESS_CAPTURE_REPLAY.0,
+            "DEVICE_ADDRESS_CAPTURE_REPLAY",
+        )];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for MicromapTypeEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::OPACITY_MICROMAP => Some("OPACITY_MICROMAP"),
+            Self::DISPLACEMENT_MICROMAP_NV => Some("DISPLACEMENT_MICROMAP_NV"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for OpacityMicromapFormatEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::TYPE_2_STATE => Some("TYPE_2_STATE"),
+            Self::TYPE_4_STATE => Some("TYPE_4_STATE"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for OpacityMicromapSpecialIndexEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::FULLY_TRANSPARENT => Some("FULLY_TRANSPARENT"),
+            Self::FULLY_OPAQUE => Some("FULLY_OPAQUE"),
+            Self::FULLY_UNKNOWN_TRANSPARENT => Some("FULLY_UNKNOWN_TRANSPARENT"),
+            Self::FULLY_UNKNOWN_OPAQUE => Some("FULLY_UNKNOWN_OPAQUE"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for OpticalFlowExecuteFlagsNV {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[(
+            OpticalFlowExecuteFlagsNV::DISABLE_TEMPORAL_HINTS.0,
+            "DISABLE_TEMPORAL_HINTS",
+        )];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for OpticalFlowGridSizeFlagsNV {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (OpticalFlowGridSizeFlagsNV::UNKNOWN.0, "UNKNOWN"),
+            (OpticalFlowGridSizeFlagsNV::TYPE_1X1.0, "TYPE_1X1"),
+            (OpticalFlowGridSizeFlagsNV::TYPE_2X2.0, "TYPE_2X2"),
+            (OpticalFlowGridSizeFlagsNV::TYPE_4X4.0, "TYPE_4X4"),
+            (OpticalFlowGridSizeFlagsNV::TYPE_8X8.0, "TYPE_8X8"),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for OpticalFlowPerformanceLevelNV {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
             Self::UNKNOWN => Some("UNKNOWN"),
-            Self::INSTANCE => Some("INSTANCE"),
-            Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"),
-            Self::DEVICE => Some("DEVICE"),
-            Self::QUEUE => Some("QUEUE"),
-            Self::SEMAPHORE => Some("SEMAPHORE"),
-            Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"),
-            Self::FENCE => Some("FENCE"),
-            Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"),
-            Self::BUFFER => Some("BUFFER"),
-            Self::IMAGE => Some("IMAGE"),
-            Self::EVENT => Some("EVENT"),
-            Self::QUERY_POOL => Some("QUERY_POOL"),
-            Self::BUFFER_VIEW => Some("BUFFER_VIEW"),
-            Self::IMAGE_VIEW => Some("IMAGE_VIEW"),
-            Self::SHADER_MODULE => Some("SHADER_MODULE"),
-            Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"),
-            Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"),
-            Self::RENDER_PASS => Some("RENDER_PASS"),
-            Self::PIPELINE => Some("PIPELINE"),
-            Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"),
-            Self::SAMPLER => Some("SAMPLER"),
-            Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"),
-            Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"),
-            Self::FRAMEBUFFER => Some("FRAMEBUFFER"),
-            Self::COMMAND_POOL => Some("COMMAND_POOL"),
-            Self::SURFACE_KHR => Some("SURFACE_KHR"),
-            Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"),
-            Self::DISPLAY_KHR => Some("DISPLAY_KHR"),
-            Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"),
-            Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"),
-            Self::VIDEO_SESSION_KHR => Some("VIDEO_SESSION_KHR"),
-            Self::VIDEO_SESSION_PARAMETERS_KHR => Some("VIDEO_SESSION_PARAMETERS_KHR"),
-            Self::CU_MODULE_NVX => Some("CU_MODULE_NVX"),
-            Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"),
-            Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"),
-            Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
-            Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"),
-            Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
-            Self::PERFORMANCE_CONFIGURATION_INTEL => Some("PERFORMANCE_CONFIGURATION_INTEL"),
-            Self::DEFERRED_OPERATION_KHR => Some("DEFERRED_OPERATION_KHR"),
-            Self::INDIRECT_COMMANDS_LAYOUT_NV => Some("INDIRECT_COMMANDS_LAYOUT_NV"),
-            Self::PRIVATE_DATA_SLOT_EXT => Some("PRIVATE_DATA_SLOT_EXT"),
-            Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"),
-            Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"),
+            Self::SLOW => Some("SLOW"),
+            Self::MEDIUM => Some("MEDIUM"),
+            Self::FAST => Some("FAST"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for OpticalFlowSessionBindingPointNV {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::UNKNOWN => Some("UNKNOWN"),
+            Self::INPUT => Some("INPUT"),
+            Self::REFERENCE => Some("REFERENCE"),
+            Self::HINT => Some("HINT"),
+            Self::FLOW_VECTOR => Some("FLOW_VECTOR"),
+            Self::BACKWARD_FLOW_VECTOR => Some("BACKWARD_FLOW_VECTOR"),
+            Self::COST => Some("COST"),
+            Self::BACKWARD_COST => Some("BACKWARD_COST"),
+            Self::GLOBAL_FLOW => Some("GLOBAL_FLOW"),
             _ => None,
         };
         if let Some(x) = name {
@@ -2559,6 +3116,46 @@ impl fmt::Debug for ObjectType {
         }
     }
 }
+impl fmt::Debug for OpticalFlowSessionCreateFlagsNV {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                OpticalFlowSessionCreateFlagsNV::ENABLE_HINT.0,
+                "ENABLE_HINT",
+            ),
+            (
+                OpticalFlowSessionCreateFlagsNV::ENABLE_COST.0,
+                "ENABLE_COST",
+            ),
+            (
+                OpticalFlowSessionCreateFlagsNV::ENABLE_GLOBAL_FLOW.0,
+                "ENABLE_GLOBAL_FLOW",
+            ),
+            (
+                OpticalFlowSessionCreateFlagsNV::ALLOW_REGIONS.0,
+                "ALLOW_REGIONS",
+            ),
+            (
+                OpticalFlowSessionCreateFlagsNV::BOTH_DIRECTIONS.0,
+                "BOTH_DIRECTIONS",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for OpticalFlowUsageFlagsNV {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (OpticalFlowUsageFlagsNV::UNKNOWN.0, "UNKNOWN"),
+            (OpticalFlowUsageFlagsNV::INPUT.0, "INPUT"),
+            (OpticalFlowUsageFlagsNV::OUTPUT.0, "OUTPUT"),
+            (OpticalFlowUsageFlagsNV::HINT.0, "HINT"),
+            (OpticalFlowUsageFlagsNV::COST.0, "COST"),
+            (OpticalFlowUsageFlagsNV::GLOBAL_FLOW.0, "GLOBAL_FLOW"),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for PeerMemoryFeatureFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
@@ -2736,14 +3333,10 @@ impl fmt::Debug for PipelineBindPoint {
 }
 impl fmt::Debug for PipelineCacheCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[
-            (PipelineCacheCreateFlags::RESERVED_1_EXT.0, "RESERVED_1_EXT"),
-            (
-                PipelineCacheCreateFlags::EXTERNALLY_SYNCHRONIZED_EXT.0,
-                "EXTERNALLY_SYNCHRONIZED_EXT",
-            ),
-            (PipelineCacheCreateFlags::RESERVED_2_KHR.0, "RESERVED_2_KHR"),
-        ];
+        const KNOWN: &[(Flags, &str)] = &[(
+            PipelineCacheCreateFlags::EXTERNALLY_SYNCHRONIZED.0,
+            "EXTERNALLY_SYNCHRONIZED",
+        )];
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -2762,7 +3355,10 @@ impl fmt::Debug for PipelineCacheHeaderVersion {
 }
 impl fmt::Debug for PipelineColorBlendStateCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[];
+        const KNOWN: &[(Flags, &str)] = &[(
+            PipelineColorBlendStateCreateFlags::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT.0,
+            "RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT",
+        )];
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -2802,8 +3398,14 @@ impl fmt::Debug for PipelineCreateFlags {
                 "ALLOW_DERIVATIVES",
             ),
             (PipelineCreateFlags::DERIVATIVE.0, "DERIVATIVE"),
-            (PipelineCreateFlags::RESERVED_21_AMD.0, "RESERVED_21_AMD"),
-            (PipelineCreateFlags::RESERVED_22_AMD.0, "RESERVED_22_AMD"),
+            (
+                PipelineCreateFlags::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0,
+                "RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR",
+            ),
+            (
+                PipelineCreateFlags::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0,
+                "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT",
+            ),
             (
                 PipelineCreateFlags::RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR.0,
                 "RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR",
@@ -2847,38 +3449,72 @@ impl fmt::Debug for PipelineCreateFlags {
             ),
             (PipelineCreateFlags::LIBRARY_KHR.0, "LIBRARY_KHR"),
             (
-                PipelineCreateFlags::FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT.0,
-                "FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT",
+                PipelineCreateFlags::DESCRIPTOR_BUFFER_EXT.0,
+                "DESCRIPTOR_BUFFER_EXT",
+            ),
+            (
+                PipelineCreateFlags::RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT.0,
+                "RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT",
             ),
             (
-                PipelineCreateFlags::EARLY_RETURN_ON_FAILURE_EXT.0,
-                "EARLY_RETURN_ON_FAILURE_EXT",
+                PipelineCreateFlags::LINK_TIME_OPTIMIZATION_EXT.0,
+                "LINK_TIME_OPTIMIZATION_EXT",
             ),
-            (PipelineCreateFlags::RESERVED_23_AMD.0, "RESERVED_23_AMD"),
-            (PipelineCreateFlags::RESERVED_10_AMD.0, "RESERVED_10_AMD"),
             (
                 PipelineCreateFlags::RAY_TRACING_ALLOW_MOTION_NV.0,
                 "RAY_TRACING_ALLOW_MOTION_NV",
             ),
             (
+                PipelineCreateFlags::COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT.0,
+                "COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT",
+            ),
+            (
+                PipelineCreateFlags::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT.0,
+                "DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT",
+            ),
+            (
+                PipelineCreateFlags::RAY_TRACING_OPACITY_MICROMAP_EXT.0,
+                "RAY_TRACING_OPACITY_MICROMAP_EXT",
+            ),
+            (
+                PipelineCreateFlags::RAY_TRACING_DISPLACEMENT_MICROMAP_NV.0,
+                "RAY_TRACING_DISPLACEMENT_MICROMAP_NV",
+            ),
+            (
+                PipelineCreateFlags::NO_PROTECTED_ACCESS_EXT.0,
+                "NO_PROTECTED_ACCESS_EXT",
+            ),
+            (
+                PipelineCreateFlags::PROTECTED_ACCESS_ONLY_EXT.0,
+                "PROTECTED_ACCESS_ONLY_EXT",
+            ),
+            (
                 PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0,
                 "VIEW_INDEX_FROM_DEVICE_INDEX",
             ),
             (PipelineCreateFlags::DISPATCH_BASE.0, "DISPATCH_BASE"),
+            (
+                PipelineCreateFlags::FAIL_ON_PIPELINE_COMPILE_REQUIRED.0,
+                "FAIL_ON_PIPELINE_COMPILE_REQUIRED",
+            ),
+            (
+                PipelineCreateFlags::EARLY_RETURN_ON_FAILURE.0,
+                "EARLY_RETURN_ON_FAILURE",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for PipelineCreationFeedbackFlagsEXT {
+impl fmt::Debug for PipelineCreationFeedbackFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (PipelineCreationFeedbackFlagsEXT::VALID.0, "VALID"),
+            (PipelineCreationFeedbackFlags::VALID.0, "VALID"),
             (
-                PipelineCreationFeedbackFlagsEXT::APPLICATION_PIPELINE_CACHE_HIT.0,
+                PipelineCreationFeedbackFlags::APPLICATION_PIPELINE_CACHE_HIT.0,
                 "APPLICATION_PIPELINE_CACHE_HIT",
             ),
             (
-                PipelineCreationFeedbackFlagsEXT::BASE_PIPELINE_ACCELERATION.0,
+                PipelineCreationFeedbackFlags::BASE_PIPELINE_ACCELERATION.0,
                 "BASE_PIPELINE_ACCELERATION",
             ),
         ];
@@ -2887,7 +3523,7 @@ impl fmt::Debug for PipelineCreationFeedbackFlagsEXT {
 }
 impl fmt::Debug for PipelineDepthStencilStateCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[];
+        const KNOWN : & [(Flags , & str)] = & [(PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT . 0 , "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT") , (PipelineDepthStencilStateCreateFlags :: RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT . 0 , "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT")] ;
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -2927,10 +3563,16 @@ impl fmt::Debug for PipelineInputAssemblyStateCreateFlags {
 }
 impl fmt::Debug for PipelineLayoutCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[(
-            PipelineLayoutCreateFlags::RESERVED_0_AMD.0,
-            "RESERVED_0_AMD",
-        )];
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                PipelineLayoutCreateFlags::RESERVED_0_AMD.0,
+                "RESERVED_0_AMD",
+            ),
+            (
+                PipelineLayoutCreateFlags::INDEPENDENT_SETS_EXT.0,
+                "INDEPENDENT_SETS_EXT",
+            ),
+        ];
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -2964,24 +3606,52 @@ impl fmt::Debug for PipelineRasterizationStateStreamCreateFlagsEXT {
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for PipelineRobustnessBufferBehaviorEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::DEVICE_DEFAULT => Some("DEVICE_DEFAULT"),
+            Self::DISABLED => Some("DISABLED"),
+            Self::ROBUST_BUFFER_ACCESS => Some("ROBUST_BUFFER_ACCESS"),
+            Self::ROBUST_BUFFER_ACCESS_2 => Some("ROBUST_BUFFER_ACCESS_2"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for PipelineRobustnessImageBehaviorEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::DEVICE_DEFAULT => Some("DEVICE_DEFAULT"),
+            Self::DISABLED => Some("DISABLED"),
+            Self::ROBUST_IMAGE_ACCESS => Some("ROBUST_IMAGE_ACCESS"),
+            Self::ROBUST_IMAGE_ACCESS_2 => Some("ROBUST_IMAGE_ACCESS_2"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for PipelineShaderStageCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
             (
-                PipelineShaderStageCreateFlags::RESERVED_2_NV.0,
-                "RESERVED_2_NV",
-            ),
-            (
-                PipelineShaderStageCreateFlags::ALLOW_VARYING_SUBGROUP_SIZE_EXT.0,
-                "ALLOW_VARYING_SUBGROUP_SIZE_EXT",
+                PipelineShaderStageCreateFlags::RESERVED_3_KHR.0,
+                "RESERVED_3_KHR",
             ),
             (
-                PipelineShaderStageCreateFlags::REQUIRE_FULL_SUBGROUPS_EXT.0,
-                "REQUIRE_FULL_SUBGROUPS_EXT",
+                PipelineShaderStageCreateFlags::ALLOW_VARYING_SUBGROUP_SIZE.0,
+                "ALLOW_VARYING_SUBGROUP_SIZE",
             ),
             (
-                PipelineShaderStageCreateFlags::RESERVED_3_KHR.0,
-                "RESERVED_3_KHR",
+                PipelineShaderStageCreateFlags::REQUIRE_FULL_SUBGROUPS.0,
+                "REQUIRE_FULL_SUBGROUPS",
             ),
         ];
         debug_flags(f, KNOWN, self.0)
@@ -3038,8 +3708,6 @@ impl fmt::Debug for PipelineStageFlags {
                 PipelineStageFlags::RAY_TRACING_SHADER_KHR.0,
                 "RAY_TRACING_SHADER_KHR",
             ),
-            (PipelineStageFlags::TASK_SHADER_NV.0, "TASK_SHADER_NV"),
-            (PipelineStageFlags::MESH_SHADER_NV.0, "MESH_SHADER_NV"),
             (
                 PipelineStageFlags::FRAGMENT_DENSITY_PROCESS_EXT.0,
                 "FRAGMENT_DENSITY_PROCESS_EXT",
@@ -3052,100 +3720,117 @@ impl fmt::Debug for PipelineStageFlags {
                 PipelineStageFlags::COMMAND_PREPROCESS_NV.0,
                 "COMMAND_PREPROCESS_NV",
             ),
-            (PipelineStageFlags::NONE_KHR.0, "NONE_KHR"),
+            (PipelineStageFlags::TASK_SHADER_EXT.0, "TASK_SHADER_EXT"),
+            (PipelineStageFlags::MESH_SHADER_EXT.0, "MESH_SHADER_EXT"),
+            (PipelineStageFlags::NONE.0, "NONE"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for PipelineStageFlags2KHR {
+impl fmt::Debug for PipelineStageFlags2 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags64, &str)] = &[
-            (PipelineStageFlags2KHR::NONE.0, "NONE"),
-            (PipelineStageFlags2KHR::TOP_OF_PIPE.0, "TOP_OF_PIPE"),
-            (PipelineStageFlags2KHR::DRAW_INDIRECT.0, "DRAW_INDIRECT"),
-            (PipelineStageFlags2KHR::VERTEX_INPUT.0, "VERTEX_INPUT"),
-            (PipelineStageFlags2KHR::VERTEX_SHADER.0, "VERTEX_SHADER"),
+            (PipelineStageFlags2::NONE.0, "NONE"),
+            (PipelineStageFlags2::TOP_OF_PIPE.0, "TOP_OF_PIPE"),
+            (PipelineStageFlags2::DRAW_INDIRECT.0, "DRAW_INDIRECT"),
+            (PipelineStageFlags2::VERTEX_INPUT.0, "VERTEX_INPUT"),
+            (PipelineStageFlags2::VERTEX_SHADER.0, "VERTEX_SHADER"),
             (
-                PipelineStageFlags2KHR::TESSELLATION_CONTROL_SHADER.0,
+                PipelineStageFlags2::TESSELLATION_CONTROL_SHADER.0,
                 "TESSELLATION_CONTROL_SHADER",
             ),
             (
-                PipelineStageFlags2KHR::TESSELLATION_EVALUATION_SHADER.0,
+                PipelineStageFlags2::TESSELLATION_EVALUATION_SHADER.0,
                 "TESSELLATION_EVALUATION_SHADER",
             ),
-            (PipelineStageFlags2KHR::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"),
-            (PipelineStageFlags2KHR::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"),
+            (PipelineStageFlags2::GEOMETRY_SHADER.0, "GEOMETRY_SHADER"),
+            (PipelineStageFlags2::FRAGMENT_SHADER.0, "FRAGMENT_SHADER"),
             (
-                PipelineStageFlags2KHR::EARLY_FRAGMENT_TESTS.0,
+                PipelineStageFlags2::EARLY_FRAGMENT_TESTS.0,
                 "EARLY_FRAGMENT_TESTS",
             ),
             (
-                PipelineStageFlags2KHR::LATE_FRAGMENT_TESTS.0,
+                PipelineStageFlags2::LATE_FRAGMENT_TESTS.0,
                 "LATE_FRAGMENT_TESTS",
             ),
             (
-                PipelineStageFlags2KHR::COLOR_ATTACHMENT_OUTPUT.0,
+                PipelineStageFlags2::COLOR_ATTACHMENT_OUTPUT.0,
                 "COLOR_ATTACHMENT_OUTPUT",
             ),
-            (PipelineStageFlags2KHR::COMPUTE_SHADER.0, "COMPUTE_SHADER"),
-            (PipelineStageFlags2KHR::ALL_TRANSFER.0, "ALL_TRANSFER"),
-            (PipelineStageFlags2KHR::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"),
-            (PipelineStageFlags2KHR::HOST.0, "HOST"),
-            (PipelineStageFlags2KHR::ALL_GRAPHICS.0, "ALL_GRAPHICS"),
-            (PipelineStageFlags2KHR::ALL_COMMANDS.0, "ALL_COMMANDS"),
-            (PipelineStageFlags2KHR::COPY.0, "COPY"),
-            (PipelineStageFlags2KHR::RESOLVE.0, "RESOLVE"),
-            (PipelineStageFlags2KHR::BLIT.0, "BLIT"),
-            (PipelineStageFlags2KHR::CLEAR.0, "CLEAR"),
-            (PipelineStageFlags2KHR::INDEX_INPUT.0, "INDEX_INPUT"),
-            (
-                PipelineStageFlags2KHR::VERTEX_ATTRIBUTE_INPUT.0,
+            (PipelineStageFlags2::COMPUTE_SHADER.0, "COMPUTE_SHADER"),
+            (PipelineStageFlags2::ALL_TRANSFER.0, "ALL_TRANSFER"),
+            (PipelineStageFlags2::BOTTOM_OF_PIPE.0, "BOTTOM_OF_PIPE"),
+            (PipelineStageFlags2::HOST.0, "HOST"),
+            (PipelineStageFlags2::ALL_GRAPHICS.0, "ALL_GRAPHICS"),
+            (PipelineStageFlags2::ALL_COMMANDS.0, "ALL_COMMANDS"),
+            (PipelineStageFlags2::COPY.0, "COPY"),
+            (PipelineStageFlags2::RESOLVE.0, "RESOLVE"),
+            (PipelineStageFlags2::BLIT.0, "BLIT"),
+            (PipelineStageFlags2::CLEAR.0, "CLEAR"),
+            (PipelineStageFlags2::INDEX_INPUT.0, "INDEX_INPUT"),
+            (
+                PipelineStageFlags2::VERTEX_ATTRIBUTE_INPUT.0,
                 "VERTEX_ATTRIBUTE_INPUT",
             ),
             (
-                PipelineStageFlags2KHR::PRE_RASTERIZATION_SHADERS.0,
+                PipelineStageFlags2::PRE_RASTERIZATION_SHADERS.0,
                 "PRE_RASTERIZATION_SHADERS",
             ),
-            (PipelineStageFlags2KHR::VIDEO_DECODE.0, "VIDEO_DECODE"),
-            (PipelineStageFlags2KHR::VIDEO_ENCODE.0, "VIDEO_ENCODE"),
+            (PipelineStageFlags2::VIDEO_DECODE_KHR.0, "VIDEO_DECODE_KHR"),
+            (PipelineStageFlags2::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"),
             (
-                PipelineStageFlags2KHR::TRANSFORM_FEEDBACK_EXT.0,
+                PipelineStageFlags2::TRANSFORM_FEEDBACK_EXT.0,
                 "TRANSFORM_FEEDBACK_EXT",
             ),
             (
-                PipelineStageFlags2KHR::CONDITIONAL_RENDERING_EXT.0,
+                PipelineStageFlags2::CONDITIONAL_RENDERING_EXT.0,
                 "CONDITIONAL_RENDERING_EXT",
             ),
             (
-                PipelineStageFlags2KHR::COMMAND_PREPROCESS_NV.0,
+                PipelineStageFlags2::COMMAND_PREPROCESS_NV.0,
                 "COMMAND_PREPROCESS_NV",
             ),
             (
-                PipelineStageFlags2KHR::FRAGMENT_SHADING_RATE_ATTACHMENT.0,
-                "FRAGMENT_SHADING_RATE_ATTACHMENT",
+                PipelineStageFlags2::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR.0,
+                "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR",
             ),
             (
-                PipelineStageFlags2KHR::ACCELERATION_STRUCTURE_BUILD.0,
-                "ACCELERATION_STRUCTURE_BUILD",
+                PipelineStageFlags2::ACCELERATION_STRUCTURE_BUILD_KHR.0,
+                "ACCELERATION_STRUCTURE_BUILD_KHR",
             ),
             (
-                PipelineStageFlags2KHR::RAY_TRACING_SHADER.0,
-                "RAY_TRACING_SHADER",
+                PipelineStageFlags2::RAY_TRACING_SHADER_KHR.0,
+                "RAY_TRACING_SHADER_KHR",
             ),
             (
-                PipelineStageFlags2KHR::FRAGMENT_DENSITY_PROCESS_EXT.0,
+                PipelineStageFlags2::FRAGMENT_DENSITY_PROCESS_EXT.0,
                 "FRAGMENT_DENSITY_PROCESS_EXT",
             ),
-            (PipelineStageFlags2KHR::TASK_SHADER_NV.0, "TASK_SHADER_NV"),
-            (PipelineStageFlags2KHR::MESH_SHADER_NV.0, "MESH_SHADER_NV"),
+            (PipelineStageFlags2::TASK_SHADER_EXT.0, "TASK_SHADER_EXT"),
+            (PipelineStageFlags2::MESH_SHADER_EXT.0, "MESH_SHADER_EXT"),
             (
-                PipelineStageFlags2KHR::SUBPASS_SHADING_HUAWEI.0,
+                PipelineStageFlags2::SUBPASS_SHADING_HUAWEI.0,
                 "SUBPASS_SHADING_HUAWEI",
             ),
             (
-                PipelineStageFlags2KHR::INVOCATION_MASK_HUAWEI.0,
+                PipelineStageFlags2::INVOCATION_MASK_HUAWEI.0,
                 "INVOCATION_MASK_HUAWEI",
             ),
+            (
+                PipelineStageFlags2::ACCELERATION_STRUCTURE_COPY_KHR.0,
+                "ACCELERATION_STRUCTURE_COPY_KHR",
+            ),
+            (
+                PipelineStageFlags2::MICROMAP_BUILD_EXT.0,
+                "MICROMAP_BUILD_EXT",
+            ),
+            (
+                PipelineStageFlags2::CLUSTER_CULLING_SHADER_HUAWEI.0,
+                "CLUSTER_CULLING_SHADER_HUAWEI",
+            ),
+            (PipelineStageFlags2::RESERVED_43_ARM.0, "RESERVED_43_ARM"),
+            (PipelineStageFlags2::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"),
+            (PipelineStageFlags2::RESERVED_42_EXT.0, "RESERVED_42_EXT"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -3204,6 +3889,16 @@ impl fmt::Debug for PolygonMode {
         }
     }
 }
+impl fmt::Debug for PresentGravityFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (PresentGravityFlagsEXT::MIN.0, "MIN"),
+            (PresentGravityFlagsEXT::MAX.0, "MAX"),
+            (PresentGravityFlagsEXT::CENTERED.0, "CENTERED"),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for PresentModeKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -3222,6 +3917,19 @@ impl fmt::Debug for PresentModeKHR {
         }
     }
 }
+impl fmt::Debug for PresentScalingFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (PresentScalingFlagsEXT::ONE_TO_ONE.0, "ONE_TO_ONE"),
+            (
+                PresentScalingFlagsEXT::ASPECT_RATIO_STRETCH.0,
+                "ASPECT_RATIO_STRETCH",
+            ),
+            (PresentScalingFlagsEXT::STRETCH.0, "STRETCH"),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for PrimitiveTopology {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -3245,9 +3953,10 @@ impl fmt::Debug for PrimitiveTopology {
         }
     }
 }
-impl fmt::Debug for PrivateDataSlotCreateFlagsEXT {
+impl fmt::Debug for PrivateDataSlotCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[];
+        const KNOWN: &[(Flags, &str)] =
+            &[(PrivateDataSlotCreateFlags::RESERVED_0_NV.0, "RESERVED_0_NV")];
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -3318,6 +4027,18 @@ impl fmt::Debug for QueryPipelineStatisticFlags {
                 QueryPipelineStatisticFlags::COMPUTE_SHADER_INVOCATIONS.0,
                 "COMPUTE_SHADER_INVOCATIONS",
             ),
+            (
+                QueryPipelineStatisticFlags::TASK_SHADER_INVOCATIONS_EXT.0,
+                "TASK_SHADER_INVOCATIONS_EXT",
+            ),
+            (
+                QueryPipelineStatisticFlags::MESH_SHADER_INVOCATIONS_EXT.0,
+                "MESH_SHADER_INVOCATIONS_EXT",
+            ),
+            (
+                QueryPipelineStatisticFlags::CLUSTER_CULLING_SHADER_INVOCATIONS_HUAWEI.0,
+                "CLUSTER_CULLING_SHADER_INVOCATIONS_HUAWEI",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -3387,9 +4108,15 @@ impl fmt::Debug for QueryType {
                 Some("ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV")
             }
             Self::PERFORMANCE_QUERY_INTEL => Some("PERFORMANCE_QUERY_INTEL"),
-            Self::VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR => {
-                Some("VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR")
-            }
+            Self::VIDEO_ENCODE_FEEDBACK_KHR => Some("VIDEO_ENCODE_FEEDBACK_KHR"),
+            Self::MESH_PRIMITIVES_GENERATED_EXT => Some("MESH_PRIMITIVES_GENERATED_EXT"),
+            Self::PRIMITIVES_GENERATED_EXT => Some("PRIMITIVES_GENERATED_EXT"),
+            Self::ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR => {
+                Some("ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR")
+            }
+            Self::ACCELERATION_STRUCTURE_SIZE_KHR => Some("ACCELERATION_STRUCTURE_SIZE_KHR"),
+            Self::MICROMAP_SERIALIZATION_SIZE_EXT => Some("MICROMAP_SERIALIZATION_SIZE_EXT"),
+            Self::MICROMAP_COMPACTED_SIZE_EXT => Some("MICROMAP_COMPACTED_SIZE_EXT"),
             _ => None,
         };
         if let Some(x) = name {
@@ -3407,13 +4134,18 @@ impl fmt::Debug for QueueFlags {
             (QueueFlags::TRANSFER.0, "TRANSFER"),
             (QueueFlags::SPARSE_BINDING.0, "SPARSE_BINDING"),
             (QueueFlags::VIDEO_DECODE_KHR.0, "VIDEO_DECODE_KHR"),
+            (QueueFlags::RESERVED_9_EXT.0, "RESERVED_9_EXT"),
             (QueueFlags::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"),
+            (QueueFlags::RESERVED_7_QCOM.0, "RESERVED_7_QCOM"),
+            (QueueFlags::RESERVED_11_ARM.0, "RESERVED_11_ARM"),
+            (QueueFlags::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"),
+            (QueueFlags::RESERVED_10_EXT.0, "RESERVED_10_EXT"),
             (QueueFlags::PROTECTED.0, "PROTECTED"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for QueueGlobalPriorityEXT {
+impl fmt::Debug for QueueGlobalPriorityKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
             Self::LOW => Some("LOW"),
@@ -3443,6 +4175,20 @@ impl fmt::Debug for RasterizationOrderAMD {
         }
     }
 }
+impl fmt::Debug for RayTracingInvocationReorderModeNV {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::NONE => Some("NONE"),
+            Self::REORDER => Some("REORDER"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for RayTracingShaderGroupTypeKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -3467,6 +4213,23 @@ impl fmt::Debug for RenderPassCreateFlags {
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for RenderingFlags {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (
+                RenderingFlags::CONTENTS_SECONDARY_COMMAND_BUFFERS.0,
+                "CONTENTS_SECONDARY_COMMAND_BUFFERS",
+            ),
+            (RenderingFlags::SUSPENDING.0, "SUSPENDING"),
+            (RenderingFlags::RESUMING.0, "RESUMING"),
+            (
+                RenderingFlags::ENABLE_LEGACY_DITHERING_EXT.0,
+                "ENABLE_LEGACY_DITHERING_EXT",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for ResolveModeFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
@@ -3475,66 +4238,14 @@ impl fmt::Debug for ResolveModeFlags {
             (ResolveModeFlags::AVERAGE.0, "AVERAGE"),
             (ResolveModeFlags::MIN.0, "MIN"),
             (ResolveModeFlags::MAX.0, "MAX"),
+            (
+                ResolveModeFlags::EXTENSION_469_FLAG_0.0,
+                "EXTENSION_469_FLAG_0",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for Result {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let name = match *self {
-            Self::SUCCESS => Some("SUCCESS"),
-            Self::NOT_READY => Some("NOT_READY"),
-            Self::TIMEOUT => Some("TIMEOUT"),
-            Self::EVENT_SET => Some("EVENT_SET"),
-            Self::EVENT_RESET => Some("EVENT_RESET"),
-            Self::INCOMPLETE => Some("INCOMPLETE"),
-            Self::ERROR_OUT_OF_HOST_MEMORY => Some("ERROR_OUT_OF_HOST_MEMORY"),
-            Self::ERROR_OUT_OF_DEVICE_MEMORY => Some("ERROR_OUT_OF_DEVICE_MEMORY"),
-            Self::ERROR_INITIALIZATION_FAILED => Some("ERROR_INITIALIZATION_FAILED"),
-            Self::ERROR_DEVICE_LOST => Some("ERROR_DEVICE_LOST"),
-            Self::ERROR_MEMORY_MAP_FAILED => Some("ERROR_MEMORY_MAP_FAILED"),
-            Self::ERROR_LAYER_NOT_PRESENT => Some("ERROR_LAYER_NOT_PRESENT"),
-            Self::ERROR_EXTENSION_NOT_PRESENT => Some("ERROR_EXTENSION_NOT_PRESENT"),
-            Self::ERROR_FEATURE_NOT_PRESENT => Some("ERROR_FEATURE_NOT_PRESENT"),
-            Self::ERROR_INCOMPATIBLE_DRIVER => Some("ERROR_INCOMPATIBLE_DRIVER"),
-            Self::ERROR_TOO_MANY_OBJECTS => Some("ERROR_TOO_MANY_OBJECTS"),
-            Self::ERROR_FORMAT_NOT_SUPPORTED => Some("ERROR_FORMAT_NOT_SUPPORTED"),
-            Self::ERROR_FRAGMENTED_POOL => Some("ERROR_FRAGMENTED_POOL"),
-            Self::ERROR_UNKNOWN => Some("ERROR_UNKNOWN"),
-            Self::ERROR_SURFACE_LOST_KHR => Some("ERROR_SURFACE_LOST_KHR"),
-            Self::ERROR_NATIVE_WINDOW_IN_USE_KHR => Some("ERROR_NATIVE_WINDOW_IN_USE_KHR"),
-            Self::SUBOPTIMAL_KHR => Some("SUBOPTIMAL_KHR"),
-            Self::ERROR_OUT_OF_DATE_KHR => Some("ERROR_OUT_OF_DATE_KHR"),
-            Self::ERROR_INCOMPATIBLE_DISPLAY_KHR => Some("ERROR_INCOMPATIBLE_DISPLAY_KHR"),
-            Self::ERROR_VALIDATION_FAILED_EXT => Some("ERROR_VALIDATION_FAILED_EXT"),
-            Self::ERROR_INVALID_SHADER_NV => Some("ERROR_INVALID_SHADER_NV"),
-            Self::ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT => {
-                Some("ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT")
-            }
-            Self::ERROR_NOT_PERMITTED_EXT => Some("ERROR_NOT_PERMITTED_EXT"),
-            Self::ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT => {
-                Some("ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT")
-            }
-            Self::THREAD_IDLE_KHR => Some("THREAD_IDLE_KHR"),
-            Self::THREAD_DONE_KHR => Some("THREAD_DONE_KHR"),
-            Self::OPERATION_DEFERRED_KHR => Some("OPERATION_DEFERRED_KHR"),
-            Self::OPERATION_NOT_DEFERRED_KHR => Some("OPERATION_NOT_DEFERRED_KHR"),
-            Self::PIPELINE_COMPILE_REQUIRED_EXT => Some("PIPELINE_COMPILE_REQUIRED_EXT"),
-            Self::ERROR_OUT_OF_POOL_MEMORY => Some("ERROR_OUT_OF_POOL_MEMORY"),
-            Self::ERROR_INVALID_EXTERNAL_HANDLE => Some("ERROR_INVALID_EXTERNAL_HANDLE"),
-            Self::ERROR_FRAGMENTATION => Some("ERROR_FRAGMENTATION"),
-            Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS => {
-                Some("ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS")
-            }
-            _ => None,
-        };
-        if let Some(x) = name {
-            f.write_str(x)
-        } else {
-            self.0.fmt(f)
-        }
-    }
-}
 impl fmt::Debug for SampleCountFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
@@ -3574,7 +4285,18 @@ impl fmt::Debug for SamplerCreateFlags {
                 SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0,
                 "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT",
             ),
-            (SamplerCreateFlags::RESERVED_2_EXT.0, "RESERVED_2_EXT"),
+            (
+                SamplerCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0,
+                "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT",
+            ),
+            (
+                SamplerCreateFlags::NON_SEAMLESS_CUBE_MAP_EXT.0,
+                "NON_SEAMLESS_CUBE_MAP_EXT",
+            ),
+            (
+                SamplerCreateFlags::IMAGE_PROCESSING_QCOM.0,
+                "IMAGE_PROCESSING_QCOM",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -3693,12 +4415,52 @@ impl fmt::Debug for SemaphoreWaitFlags {
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for ShaderCodeTypeEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::BINARY => Some("BINARY"),
+            Self::SPIRV => Some("SPIRV"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for ShaderCorePropertiesFlagsAMD {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[];
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for ShaderCreateFlagsEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (ShaderCreateFlagsEXT::LINK_STAGE.0, "LINK_STAGE"),
+            (
+                ShaderCreateFlagsEXT::ALLOW_VARYING_SUBGROUP_SIZE.0,
+                "ALLOW_VARYING_SUBGROUP_SIZE",
+            ),
+            (
+                ShaderCreateFlagsEXT::REQUIRE_FULL_SUBGROUPS.0,
+                "REQUIRE_FULL_SUBGROUPS",
+            ),
+            (ShaderCreateFlagsEXT::NO_TASK_SHADER.0, "NO_TASK_SHADER"),
+            (ShaderCreateFlagsEXT::DISPATCH_BASE.0, "DISPATCH_BASE"),
+            (
+                ShaderCreateFlagsEXT::FRAGMENT_SHADING_RATE_ATTACHMENT.0,
+                "FRAGMENT_SHADING_RATE_ATTACHMENT",
+            ),
+            (
+                ShaderCreateFlagsEXT::FRAGMENT_DENSITY_MAP_ATTACHMENT.0,
+                "FRAGMENT_DENSITY_MAP_ATTACHMENT",
+            ),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for ShaderFloatControlsIndependence {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let name = match *self {
@@ -3747,8 +4509,7 @@ impl fmt::Debug for ShaderInfoTypeAMD {
 }
 impl fmt::Debug for ShaderModuleCreateFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] =
-            &[(ShaderModuleCreateFlags::RESERVED_0_NV.0, "RESERVED_0_NV")];
+        const KNOWN: &[(Flags, &str)] = &[];
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -3775,12 +4536,16 @@ impl fmt::Debug for ShaderStageFlags {
             (ShaderStageFlags::MISS_KHR.0, "MISS_KHR"),
             (ShaderStageFlags::INTERSECTION_KHR.0, "INTERSECTION_KHR"),
             (ShaderStageFlags::CALLABLE_KHR.0, "CALLABLE_KHR"),
-            (ShaderStageFlags::TASK_NV.0, "TASK_NV"),
-            (ShaderStageFlags::MESH_NV.0, "MESH_NV"),
+            (ShaderStageFlags::TASK_EXT.0, "TASK_EXT"),
+            (ShaderStageFlags::MESH_EXT.0, "MESH_EXT"),
             (
                 ShaderStageFlags::SUBPASS_SHADING_HUAWEI.0,
                 "SUBPASS_SHADING_HUAWEI",
             ),
+            (
+                ShaderStageFlags::CLUSTER_CULLING_HUAWEI.0,
+                "CLUSTER_CULLING_HUAWEI",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -3987,11 +4752,13 @@ impl fmt::Debug for StructureType {
             Self::DEBUG_MARKER_OBJECT_NAME_INFO_EXT => Some("DEBUG_MARKER_OBJECT_NAME_INFO_EXT"),
             Self::DEBUG_MARKER_OBJECT_TAG_INFO_EXT => Some("DEBUG_MARKER_OBJECT_TAG_INFO_EXT"),
             Self::DEBUG_MARKER_MARKER_INFO_EXT => Some("DEBUG_MARKER_MARKER_INFO_EXT"),
-            Self::VIDEO_PROFILE_KHR => Some("VIDEO_PROFILE_KHR"),
+            Self::VIDEO_PROFILE_INFO_KHR => Some("VIDEO_PROFILE_INFO_KHR"),
             Self::VIDEO_CAPABILITIES_KHR => Some("VIDEO_CAPABILITIES_KHR"),
-            Self::VIDEO_PICTURE_RESOURCE_KHR => Some("VIDEO_PICTURE_RESOURCE_KHR"),
-            Self::VIDEO_GET_MEMORY_PROPERTIES_KHR => Some("VIDEO_GET_MEMORY_PROPERTIES_KHR"),
-            Self::VIDEO_BIND_MEMORY_KHR => Some("VIDEO_BIND_MEMORY_KHR"),
+            Self::VIDEO_PICTURE_RESOURCE_INFO_KHR => Some("VIDEO_PICTURE_RESOURCE_INFO_KHR"),
+            Self::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR => {
+                Some("VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR")
+            }
+            Self::BIND_VIDEO_SESSION_MEMORY_INFO_KHR => Some("BIND_VIDEO_SESSION_MEMORY_INFO_KHR"),
             Self::VIDEO_SESSION_CREATE_INFO_KHR => Some("VIDEO_SESSION_CREATE_INFO_KHR"),
             Self::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR => {
                 Some("VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR")
@@ -4002,16 +4769,19 @@ impl fmt::Debug for StructureType {
             Self::VIDEO_BEGIN_CODING_INFO_KHR => Some("VIDEO_BEGIN_CODING_INFO_KHR"),
             Self::VIDEO_END_CODING_INFO_KHR => Some("VIDEO_END_CODING_INFO_KHR"),
             Self::VIDEO_CODING_CONTROL_INFO_KHR => Some("VIDEO_CODING_CONTROL_INFO_KHR"),
-            Self::VIDEO_REFERENCE_SLOT_KHR => Some("VIDEO_REFERENCE_SLOT_KHR"),
-            Self::VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR => {
-                Some("VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR")
-            }
-            Self::VIDEO_PROFILES_KHR => Some("VIDEO_PROFILES_KHR"),
+            Self::VIDEO_REFERENCE_SLOT_INFO_KHR => Some("VIDEO_REFERENCE_SLOT_INFO_KHR"),
+            Self::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR => Some("QUEUE_FAMILY_VIDEO_PROPERTIES_KHR"),
+            Self::VIDEO_PROFILE_LIST_INFO_KHR => Some("VIDEO_PROFILE_LIST_INFO_KHR"),
             Self::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR => {
                 Some("PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR")
             }
             Self::VIDEO_FORMAT_PROPERTIES_KHR => Some("VIDEO_FORMAT_PROPERTIES_KHR"),
+            Self::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR => {
+                Some("QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR")
+            }
             Self::VIDEO_DECODE_INFO_KHR => Some("VIDEO_DECODE_INFO_KHR"),
+            Self::VIDEO_DECODE_CAPABILITIES_KHR => Some("VIDEO_DECODE_CAPABILITIES_KHR"),
+            Self::VIDEO_DECODE_USAGE_INFO_KHR => Some("VIDEO_DECODE_USAGE_INFO_KHR"),
             Self::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV => {
                 Some("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV")
             }
@@ -4036,9 +4806,6 @@ impl fmt::Debug for StructureType {
             Self::IMAGE_VIEW_HANDLE_INFO_NVX => Some("IMAGE_VIEW_HANDLE_INFO_NVX"),
             Self::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX => Some("IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"),
             Self::VIDEO_ENCODE_H264_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H264_CAPABILITIES_EXT"),
-            Self::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT => {
-                Some("VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT")
-            }
             Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => {
                 Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT")
             }
@@ -4051,30 +4818,64 @@ impl fmt::Debug for StructureType {
             Self::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT => {
                 Some("VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT")
             }
-            Self::VIDEO_ENCODE_H264_NALU_SLICE_EXT => Some("VIDEO_ENCODE_H264_NALU_SLICE_EXT"),
-            Self::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT => {
-                Some("VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT")
+            Self::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT => {
+                Some("VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H264_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H264_PROFILE_INFO_EXT"),
+            Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => {
+                Some("VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => {
+                Some("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"),
+            Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT")
+            }
+            Self::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT")
             }
-            Self::VIDEO_ENCODE_H264_PROFILE_EXT => Some("VIDEO_ENCODE_H264_PROFILE_EXT"),
-            Self::VIDEO_DECODE_H264_CAPABILITIES_EXT => Some("VIDEO_DECODE_H264_CAPABILITIES_EXT"),
-            Self::VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT => {
-                Some("VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT")
+            Self::VIDEO_ENCODE_H265_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H265_PROFILE_INFO_EXT"),
+            Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT")
             }
-            Self::VIDEO_DECODE_H264_PICTURE_INFO_EXT => Some("VIDEO_DECODE_H264_PICTURE_INFO_EXT"),
-            Self::VIDEO_DECODE_H264_MVC_EXT => Some("VIDEO_DECODE_H264_MVC_EXT"),
-            Self::VIDEO_DECODE_H264_PROFILE_EXT => Some("VIDEO_DECODE_H264_PROFILE_EXT"),
-            Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => {
-                Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT")
+            Self::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT => {
+                Some("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT")
             }
-            Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => {
-                Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT")
+            Self::VIDEO_DECODE_H264_CAPABILITIES_KHR => Some("VIDEO_DECODE_H264_CAPABILITIES_KHR"),
+            Self::VIDEO_DECODE_H264_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H264_PICTURE_INFO_KHR"),
+            Self::VIDEO_DECODE_H264_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H264_PROFILE_INFO_KHR"),
+            Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR => {
+                Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR")
             }
-            Self::VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT => {
-                Some("VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT")
+            Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR => {
+                Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR")
+            }
+            Self::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR => {
+                Some("VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR")
             }
             Self::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD => {
                 Some("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD")
             }
+            Self::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => {
+                Some("RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR")
+            }
+            Self::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT => {
+                Some("RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT")
+            }
+            Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD => Some("ATTACHMENT_SAMPLE_COUNT_INFO_AMD"),
+            Self::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX => {
+                Some("MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX")
+            }
             Self::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP => {
                 Some("STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP")
             }
@@ -4092,13 +4893,19 @@ impl fmt::Debug for StructureType {
             }
             Self::VALIDATION_FLAGS_EXT => Some("VALIDATION_FLAGS_EXT"),
             Self::VI_SURFACE_CREATE_INFO_NN => Some("VI_SURFACE_CREATE_INFO_NN"),
-            Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT => {
-                Some("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT")
-            }
             Self::IMAGE_VIEW_ASTC_DECODE_MODE_EXT => Some("IMAGE_VIEW_ASTC_DECODE_MODE_EXT"),
             Self::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT")
             }
+            Self::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT => {
+                Some("PIPELINE_ROBUSTNESS_CREATE_INFO_EXT")
+            }
+            Self::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT")
+            }
             Self::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR => {
                 Some("IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR")
             }
@@ -4230,17 +5037,8 @@ impl fmt::Debug for StructureType {
                 Some("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID")
             }
             Self::EXTERNAL_FORMAT_ANDROID => Some("EXTERNAL_FORMAT_ANDROID"),
-            Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT => {
-                Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT")
-            }
-            Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT => {
-                Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT")
-            }
-            Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT => {
-                Some("WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT")
-            }
-            Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT => {
-                Some("DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT")
+            Self::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID => {
+                Some("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID")
             }
             Self::SAMPLE_LOCATIONS_INFO_EXT => Some("SAMPLE_LOCATIONS_INFO_EXT"),
             Self::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT => {
@@ -4352,6 +5150,9 @@ impl fmt::Debug for StructureType {
             Self::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT => {
                 Some("IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT")
             }
+            Self::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT => {
+                Some("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT")
+            }
             Self::VALIDATION_CACHE_CREATE_INFO_EXT => Some("VALIDATION_CACHE_CREATE_INFO_EXT"),
             Self::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT => {
                 Some("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT")
@@ -4411,9 +5212,6 @@ impl fmt::Debug for StructureType {
             Self::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT => {
                 Some("FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT")
             }
-            Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT => {
-                Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT")
-            }
             Self::IMPORT_MEMORY_HOST_POINTER_INFO_EXT => {
                 Some("IMPORT_MEMORY_HOST_POINTER_INFO_EXT")
             }
@@ -4431,20 +5229,26 @@ impl fmt::Debug for StructureType {
             Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD => {
                 Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD")
             }
-            Self::VIDEO_DECODE_H265_CAPABILITIES_EXT => Some("VIDEO_DECODE_H265_CAPABILITIES_EXT"),
-            Self::VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT => {
-                Some("VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT")
+            Self::VIDEO_DECODE_H265_CAPABILITIES_KHR => Some("VIDEO_DECODE_H265_CAPABILITIES_KHR"),
+            Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR => {
+                Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR")
+            }
+            Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR => {
+                Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR")
             }
-            Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => {
-                Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT")
+            Self::VIDEO_DECODE_H265_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H265_PROFILE_INFO_KHR"),
+            Self::VIDEO_DECODE_H265_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H265_PICTURE_INFO_KHR"),
+            Self::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR => {
+                Some("VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR")
             }
-            Self::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => {
-                Some("VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT")
+            Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR => {
+                Some("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR")
             }
-            Self::VIDEO_DECODE_H265_PROFILE_EXT => Some("VIDEO_DECODE_H265_PROFILE_EXT"),
-            Self::VIDEO_DECODE_H265_PICTURE_INFO_EXT => Some("VIDEO_DECODE_H265_PICTURE_INFO_EXT"),
-            Self::VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT => {
-                Some("VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT")
+            Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR => {
+                Some("PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR")
+            }
+            Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR => {
+                Some("QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR")
             }
             Self::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD => {
                 Some("DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD")
@@ -4459,9 +5263,6 @@ impl fmt::Debug for StructureType {
                 Some("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT")
             }
             Self::PRESENT_FRAME_TOKEN_GGP => Some("PRESENT_FRAME_TOKEN_GGP"),
-            Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT => {
-                Some("PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT")
-            }
             Self::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV => {
                 Some("PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV")
             }
@@ -4471,9 +5272,6 @@ impl fmt::Debug for StructureType {
             Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV => {
                 Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV")
             }
-            Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV => {
-                Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV")
-            }
             Self::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV => {
                 Some("PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV")
             }
@@ -4516,9 +5314,6 @@ impl fmt::Debug for StructureType {
             Self::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA => {
                 Some("IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA")
             }
-            Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR => {
-                Some("PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR")
-            }
             Self::METAL_SURFACE_CREATE_INFO_EXT => Some("METAL_SURFACE_CREATE_INFO_EXT"),
             Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT")
@@ -4529,15 +5324,6 @@ impl fmt::Debug for StructureType {
             Self::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT => {
                 Some("RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT")
             }
-            Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT => {
-                Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT")
-            }
-            Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT => {
-                Some("PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT")
-            }
-            Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT => {
-                Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT")
-            }
             Self::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR => {
                 Some("FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR")
             }
@@ -4579,9 +5365,6 @@ impl fmt::Debug for StructureType {
             Self::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT => {
                 Some("BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT")
             }
-            Self::PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT => {
-                Some("PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT")
-            }
             Self::VALIDATION_FEATURES_EXT => Some("VALIDATION_FEATURES_EXT"),
             Self::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR => {
                 Some("PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR")
@@ -4655,12 +5438,30 @@ impl fmt::Debug for StructureType {
             Self::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR => {
                 Some("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR")
             }
+            Self::MEMORY_MAP_INFO_KHR => Some("MEMORY_MAP_INFO_KHR"),
+            Self::MEMORY_UNMAP_INFO_KHR => Some("MEMORY_UNMAP_INFO_KHR"),
             Self::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT")
             }
-            Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT => {
-                Some("PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT")
+            Self::SURFACE_PRESENT_MODE_EXT => Some("SURFACE_PRESENT_MODE_EXT"),
+            Self::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT => {
+                Some("SURFACE_PRESENT_SCALING_CAPABILITIES_EXT")
+            }
+            Self::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT => {
+                Some("SURFACE_PRESENT_MODE_COMPATIBILITY_EXT")
+            }
+            Self::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT")
             }
+            Self::SWAPCHAIN_PRESENT_FENCE_INFO_EXT => Some("SWAPCHAIN_PRESENT_FENCE_INFO_EXT"),
+            Self::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT => {
+                Some("SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT")
+            }
+            Self::SWAPCHAIN_PRESENT_MODE_INFO_EXT => Some("SWAPCHAIN_PRESENT_MODE_INFO_EXT"),
+            Self::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT => {
+                Some("SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT")
+            }
+            Self::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT => Some("RELEASE_SWAPCHAIN_IMAGES_INFO_EXT"),
             Self::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV => {
                 Some("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV")
             }
@@ -4687,18 +5488,9 @@ impl fmt::Debug for StructureType {
             Self::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV => {
                 Some("COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV")
             }
-            Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR => {
-                Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR")
-            }
-            Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR => {
-                Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR")
-            }
             Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT")
             }
-            Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT => {
-                Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT")
-            }
             Self::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM => {
                 Some("COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM")
             }
@@ -4730,22 +5522,29 @@ impl fmt::Debug for StructureType {
                 Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT")
             }
             Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"),
-            Self::PRESENT_ID_KHR => Some("PRESENT_ID_KHR"),
-            Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => {
-                Some("PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR")
+            Self::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV => {
+                Some("PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV")
             }
-            Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT => {
-                Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT")
+            Self::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV => {
+                Some("SURFACE_CAPABILITIES_PRESENT_BARRIER_NV")
             }
-            Self::DEVICE_PRIVATE_DATA_CREATE_INFO_EXT => {
-                Some("DEVICE_PRIVATE_DATA_CREATE_INFO_EXT")
+            Self::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV => {
+                Some("SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV")
             }
-            Self::PRIVATE_DATA_SLOT_CREATE_INFO_EXT => Some("PRIVATE_DATA_SLOT_CREATE_INFO_EXT"),
-            Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT => {
-                Some("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT")
+            Self::PRESENT_ID_KHR => Some("PRESENT_ID_KHR"),
+            Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => {
+                Some("PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR")
             }
             Self::VIDEO_ENCODE_INFO_KHR => Some("VIDEO_ENCODE_INFO_KHR"),
             Self::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR => Some("VIDEO_ENCODE_RATE_CONTROL_INFO_KHR"),
+            Self::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR => {
+                Some("VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR")
+            }
+            Self::VIDEO_ENCODE_CAPABILITIES_KHR => Some("VIDEO_ENCODE_CAPABILITIES_KHR"),
+            Self::VIDEO_ENCODE_USAGE_INFO_KHR => Some("VIDEO_ENCODE_USAGE_INFO_KHR"),
+            Self::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR => {
+                Some("QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR")
+            }
             Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => {
                 Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV")
             }
@@ -4753,26 +5552,81 @@ impl fmt::Debug for StructureType {
                 Some("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV")
             }
             Self::RESERVED_QCOM => Some("RESERVED_QCOM"),
-            Self::MEMORY_BARRIER_2_KHR => Some("MEMORY_BARRIER_2_KHR"),
-            Self::BUFFER_MEMORY_BARRIER_2_KHR => Some("BUFFER_MEMORY_BARRIER_2_KHR"),
-            Self::IMAGE_MEMORY_BARRIER_2_KHR => Some("IMAGE_MEMORY_BARRIER_2_KHR"),
-            Self::DEPENDENCY_INFO_KHR => Some("DEPENDENCY_INFO_KHR"),
-            Self::SUBMIT_INFO_2_KHR => Some("SUBMIT_INFO_2_KHR"),
-            Self::SEMAPHORE_SUBMIT_INFO_KHR => Some("SEMAPHORE_SUBMIT_INFO_KHR"),
-            Self::COMMAND_BUFFER_SUBMIT_INFO_KHR => Some("COMMAND_BUFFER_SUBMIT_INFO_KHR"),
-            Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR => {
-                Some("PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR")
-            }
+            Self::QUERY_LOW_LATENCY_SUPPORT_NV => Some("QUERY_LOW_LATENCY_SUPPORT_NV"),
+            Self::EXPORT_METAL_OBJECT_CREATE_INFO_EXT => {
+                Some("EXPORT_METAL_OBJECT_CREATE_INFO_EXT")
+            }
+            Self::EXPORT_METAL_OBJECTS_INFO_EXT => Some("EXPORT_METAL_OBJECTS_INFO_EXT"),
+            Self::EXPORT_METAL_DEVICE_INFO_EXT => Some("EXPORT_METAL_DEVICE_INFO_EXT"),
+            Self::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT => {
+                Some("EXPORT_METAL_COMMAND_QUEUE_INFO_EXT")
+            }
+            Self::EXPORT_METAL_BUFFER_INFO_EXT => Some("EXPORT_METAL_BUFFER_INFO_EXT"),
+            Self::IMPORT_METAL_BUFFER_INFO_EXT => Some("IMPORT_METAL_BUFFER_INFO_EXT"),
+            Self::EXPORT_METAL_TEXTURE_INFO_EXT => Some("EXPORT_METAL_TEXTURE_INFO_EXT"),
+            Self::IMPORT_METAL_TEXTURE_INFO_EXT => Some("IMPORT_METAL_TEXTURE_INFO_EXT"),
+            Self::EXPORT_METAL_IO_SURFACE_INFO_EXT => Some("EXPORT_METAL_IO_SURFACE_INFO_EXT"),
+            Self::IMPORT_METAL_IO_SURFACE_INFO_EXT => Some("IMPORT_METAL_IO_SURFACE_INFO_EXT"),
+            Self::EXPORT_METAL_SHARED_EVENT_INFO_EXT => Some("EXPORT_METAL_SHARED_EVENT_INFO_EXT"),
+            Self::IMPORT_METAL_SHARED_EVENT_INFO_EXT => Some("IMPORT_METAL_SHARED_EVENT_INFO_EXT"),
             Self::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV => {
                 Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV")
             }
             Self::CHECKPOINT_DATA_2_NV => Some("CHECKPOINT_DATA_2_NV"),
+            Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT")
+            }
+            Self::DESCRIPTOR_ADDRESS_INFO_EXT => Some("DESCRIPTOR_ADDRESS_INFO_EXT"),
+            Self::DESCRIPTOR_GET_INFO_EXT => Some("DESCRIPTOR_GET_INFO_EXT"),
+            Self::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
+                Some("BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
+            }
+            Self::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
+                Some("IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
+            }
+            Self::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
+                Some("IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
+            }
+            Self::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
+                Some("SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
+            }
+            Self::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT => {
+                Some("OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT")
+            }
+            Self::DESCRIPTOR_BUFFER_BINDING_INFO_EXT => Some("DESCRIPTOR_BUFFER_BINDING_INFO_EXT"),
+            Self::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT => {
+                Some("DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT")
+            }
+            Self::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => {
+                Some("ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT")
+            }
+            Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT")
+            }
+            Self::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT => {
+                Some("GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD => {
+                Some("PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD")
+            }
+            Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR => {
+                Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR")
+            }
+            Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR => {
+                Some("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR")
+            }
             Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR => {
                 Some("PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR")
             }
-            Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR => {
-                Some("PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR")
-            }
             Self::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV => {
                 Some("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV")
             }
@@ -4791,6 +5645,12 @@ impl fmt::Debug for StructureType {
             Self::ACCELERATION_STRUCTURE_MOTION_INFO_NV => {
                 Some("ACCELERATION_STRUCTURE_MOTION_INFO_NV")
             }
+            Self::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT")
+            }
             Self::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT")
             }
@@ -4801,33 +5661,29 @@ impl fmt::Debug for StructureType {
                 Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT")
             }
             Self::COPY_COMMAND_TRANSFORM_INFO_QCOM => Some("COPY_COMMAND_TRANSFORM_INFO_QCOM"),
-            Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT => {
-                Some("PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT")
-            }
             Self::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR => {
                 Some("PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR")
             }
-            Self::COPY_BUFFER_INFO_2_KHR => Some("COPY_BUFFER_INFO_2_KHR"),
-            Self::COPY_IMAGE_INFO_2_KHR => Some("COPY_IMAGE_INFO_2_KHR"),
-            Self::COPY_BUFFER_TO_IMAGE_INFO_2_KHR => Some("COPY_BUFFER_TO_IMAGE_INFO_2_KHR"),
-            Self::COPY_IMAGE_TO_BUFFER_INFO_2_KHR => Some("COPY_IMAGE_TO_BUFFER_INFO_2_KHR"),
-            Self::BLIT_IMAGE_INFO_2_KHR => Some("BLIT_IMAGE_INFO_2_KHR"),
-            Self::RESOLVE_IMAGE_INFO_2_KHR => Some("RESOLVE_IMAGE_INFO_2_KHR"),
-            Self::BUFFER_COPY_2_KHR => Some("BUFFER_COPY_2_KHR"),
-            Self::IMAGE_COPY_2_KHR => Some("IMAGE_COPY_2_KHR"),
-            Self::IMAGE_BLIT_2_KHR => Some("IMAGE_BLIT_2_KHR"),
-            Self::BUFFER_IMAGE_COPY_2_KHR => Some("BUFFER_IMAGE_COPY_2_KHR"),
-            Self::IMAGE_RESOLVE_2_KHR => Some("IMAGE_RESOLVE_2_KHR"),
+            Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT")
+            }
+            Self::IMAGE_COMPRESSION_CONTROL_EXT => Some("IMAGE_COMPRESSION_CONTROL_EXT"),
+            Self::SUBRESOURCE_LAYOUT_2_EXT => Some("SUBRESOURCE_LAYOUT_2_EXT"),
+            Self::IMAGE_SUBRESOURCE_2_EXT => Some("IMAGE_SUBRESOURCE_2_EXT"),
+            Self::IMAGE_COMPRESSION_PROPERTIES_EXT => Some("IMAGE_COMPRESSION_PROPERTIES_EXT"),
+            Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT")
+            }
             Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT")
             }
-            Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"),
-            Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE => {
-                Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE")
-            }
-            Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE => {
-                Some("MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE")
+            Self::PHYSICAL_DEVICE_FAULT_FEATURES_EXT => Some("PHYSICAL_DEVICE_FAULT_FEATURES_EXT"),
+            Self::DEVICE_FAULT_COUNTS_EXT => Some("DEVICE_FAULT_COUNTS_EXT"),
+            Self::DEVICE_FAULT_INFO_EXT => Some("DEVICE_FAULT_INFO_EXT"),
+            Self::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT")
             }
+            Self::DIRECTFB_SURFACE_CREATE_INFO_EXT => Some("DIRECTFB_SURFACE_CREATE_INFO_EXT"),
             Self::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT")
             }
@@ -4838,6 +5694,18 @@ impl fmt::Debug for StructureType {
                 Some("VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT")
             }
             Self::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT => Some("PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"),
+            Self::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT")
+            }
+            Self::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT => {
+                Some("DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT")
+            }
+            Self::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT")
+            }
+            Self::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT => {
+                Some("PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT")
+            }
             Self::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT")
             }
@@ -4856,6 +5724,30 @@ impl fmt::Debug for StructureType {
             Self::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA => {
                 Some("SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA")
             }
+            Self::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA => {
+                Some("BUFFER_COLLECTION_CREATE_INFO_FUCHSIA")
+            }
+            Self::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA => {
+                Some("IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA")
+            }
+            Self::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA => {
+                Some("BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA")
+            }
+            Self::BUFFER_COLLECTION_PROPERTIES_FUCHSIA => {
+                Some("BUFFER_COLLECTION_PROPERTIES_FUCHSIA")
+            }
+            Self::BUFFER_CONSTRAINTS_INFO_FUCHSIA => Some("BUFFER_CONSTRAINTS_INFO_FUCHSIA"),
+            Self::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA => {
+                Some("BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA")
+            }
+            Self::IMAGE_CONSTRAINTS_INFO_FUCHSIA => Some("IMAGE_CONSTRAINTS_INFO_FUCHSIA"),
+            Self::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA => {
+                Some("IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA")
+            }
+            Self::SYSMEM_COLOR_SPACE_FUCHSIA => Some("SYSMEM_COLOR_SPACE_FUCHSIA"),
+            Self::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA => {
+                Some("BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA")
+            }
             Self::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI => {
                 Some("SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI")
             }
@@ -4872,6 +5764,19 @@ impl fmt::Debug for StructureType {
             Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV => {
                 Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV")
             }
+            Self::PIPELINE_PROPERTIES_IDENTIFIER_EXT => Some("PIPELINE_PROPERTIES_IDENTIFIER_EXT"),
+            Self::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT")
+            }
+            Self::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT => {
+                Some("SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT")
+            }
+            Self::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT => {
+                Some("MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT")
+            }
             Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT")
             }
@@ -4882,21 +5787,237 @@ impl fmt::Debug for StructureType {
             Self::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT => {
                 Some("PIPELINE_COLOR_WRITE_CREATE_INFO_EXT")
             }
-            Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT => {
-                Some("PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT")
+            Self::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT")
             }
-            Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT => {
-                Some("QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT")
+            Self::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR => {
+                Some("PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR")
             }
+            Self::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT")
+            }
+            Self::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT => Some("IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT"),
             Self::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT")
             }
             Self::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT => {
                 Some("PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT")
             }
+            Self::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT")
+            }
+            Self::MICROMAP_BUILD_INFO_EXT => Some("MICROMAP_BUILD_INFO_EXT"),
+            Self::MICROMAP_VERSION_INFO_EXT => Some("MICROMAP_VERSION_INFO_EXT"),
+            Self::COPY_MICROMAP_INFO_EXT => Some("COPY_MICROMAP_INFO_EXT"),
+            Self::COPY_MICROMAP_TO_MEMORY_INFO_EXT => Some("COPY_MICROMAP_TO_MEMORY_INFO_EXT"),
+            Self::COPY_MEMORY_TO_MICROMAP_INFO_EXT => Some("COPY_MEMORY_TO_MICROMAP_INFO_EXT"),
+            Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT")
+            }
+            Self::MICROMAP_CREATE_INFO_EXT => Some("MICROMAP_CREATE_INFO_EXT"),
+            Self::MICROMAP_BUILD_SIZES_INFO_EXT => Some("MICROMAP_BUILD_SIZES_INFO_EXT"),
+            Self::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT => {
+                Some("ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT")
+            }
+            Self::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV => {
+                Some("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV")
+            }
+            Self::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV => {
+                Some("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV")
+            }
+            Self::ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV => {
+                Some("ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV")
+            }
+            Self::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI => {
+                Some("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI")
+            }
+            Self::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI => {
+                Some("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI")
+            }
+            Self::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT")
+            }
+            Self::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT => {
+                Some("SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT")
+            }
             Self::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT => {
                 Some("PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT")
             }
+            Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM => {
+                Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM")
+            }
+            Self::PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT")
+            }
+            Self::IMAGE_VIEW_SLICED_CREATE_INFO_EXT => Some("IMAGE_VIEW_SLICED_CREATE_INFO_EXT"),
+            Self::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE => {
+                Some("PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE")
+            }
+            Self::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE => {
+                Some("DESCRIPTOR_SET_BINDING_REFERENCE_VALVE")
+            }
+            Self::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE => {
+                Some("DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE")
+            }
+            Self::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM => {
+                Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM")
+            }
+            Self::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM => {
+                Some("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM")
+            }
+            Self::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM => {
+                Some("SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM")
+            }
+            Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV => {
+                Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV")
+            }
+            Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV => {
+                Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV")
+            }
+            Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV => {
+                Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV")
+            }
+            Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV => {
+                Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV")
+            }
+            Self::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV => {
+                Some("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV")
+            }
+            Self::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM => {
+                Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM")
+            }
+            Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM => {
+                Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM")
+            }
+            Self::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM => {
+                Some("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM")
+            }
+            Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT")
+            }
+            Self::RENDER_PASS_CREATION_CONTROL_EXT => Some("RENDER_PASS_CREATION_CONTROL_EXT"),
+            Self::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT => {
+                Some("RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT")
+            }
+            Self::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT => {
+                Some("RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT")
+            }
+            Self::DIRECT_DRIVER_LOADING_INFO_LUNARG => Some("DIRECT_DRIVER_LOADING_INFO_LUNARG"),
+            Self::DIRECT_DRIVER_LOADING_LIST_LUNARG => Some("DIRECT_DRIVER_LOADING_LIST_LUNARG"),
+            Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT")
+            }
+            Self::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT => {
+                Some("PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT")
+            }
+            Self::SHADER_MODULE_IDENTIFIER_EXT => Some("SHADER_MODULE_IDENTIFIER_EXT"),
+            Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV => {
+                Some("PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV")
+            }
+            Self::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV => {
+                Some("PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV")
+            }
+            Self::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV => Some("OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV"),
+            Self::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV => {
+                Some("OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV")
+            }
+            Self::OPTICAL_FLOW_SESSION_CREATE_INFO_NV => {
+                Some("OPTICAL_FLOW_SESSION_CREATE_INFO_NV")
+            }
+            Self::OPTICAL_FLOW_EXECUTE_INFO_NV => Some("OPTICAL_FLOW_EXECUTE_INFO_NV"),
+            Self::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV => {
+                Some("OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV")
+            }
+            Self::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR => {
+                Some("PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT => {
+                Some("PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT")
+            }
+            Self::SHADER_CREATE_INFO_EXT => Some("SHADER_CREATE_INFO_EXT"),
+            Self::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM => {
+                Some("PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM")
+            }
+            Self::TILE_PROPERTIES_QCOM => Some("TILE_PROPERTIES_QCOM"),
+            Self::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC => {
+                Some("PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC")
+            }
+            Self::AMIGO_PROFILING_SUBMIT_INFO_SEC => Some("AMIGO_PROFILING_SUBMIT_INFO_SEC"),
+            Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM => {
+                Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM")
+            }
+            Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV => {
+                Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV")
+            }
+            Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV => {
+                Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV")
+            }
+            Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT")
+            }
+            Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT => {
+                Some("MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM => {
+                Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM => {
+                Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM")
+            }
+            Self::PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT")
+            }
+            Self::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM => {
+                Some("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM")
+            }
+            Self::MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM => {
+                Some("MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM")
+            }
+            Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT => {
+                Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT")
+            }
             Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => {
                 Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES")
             }
@@ -5132,6 +6253,108 @@ impl fmt::Debug for StructureType {
             Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO => {
                 Some("DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO")
             }
+            Self::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES => {
+                Some("PHYSICAL_DEVICE_VULKAN_1_3_FEATURES")
+            }
+            Self::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES => {
+                Some("PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES")
+            }
+            Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO => {
+                Some("PIPELINE_CREATION_FEEDBACK_CREATE_INFO")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES => {
+                Some("PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES")
+            }
+            Self::PHYSICAL_DEVICE_TOOL_PROPERTIES => Some("PHYSICAL_DEVICE_TOOL_PROPERTIES"),
+            Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES => {
+                Some("PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES")
+            }
+            Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES => {
+                Some("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES")
+            }
+            Self::DEVICE_PRIVATE_DATA_CREATE_INFO => Some("DEVICE_PRIVATE_DATA_CREATE_INFO"),
+            Self::PRIVATE_DATA_SLOT_CREATE_INFO => Some("PRIVATE_DATA_SLOT_CREATE_INFO"),
+            Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES => {
+                Some("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES")
+            }
+            Self::MEMORY_BARRIER_2 => Some("MEMORY_BARRIER_2"),
+            Self::BUFFER_MEMORY_BARRIER_2 => Some("BUFFER_MEMORY_BARRIER_2"),
+            Self::IMAGE_MEMORY_BARRIER_2 => Some("IMAGE_MEMORY_BARRIER_2"),
+            Self::DEPENDENCY_INFO => Some("DEPENDENCY_INFO"),
+            Self::SUBMIT_INFO_2 => Some("SUBMIT_INFO_2"),
+            Self::SEMAPHORE_SUBMIT_INFO => Some("SEMAPHORE_SUBMIT_INFO"),
+            Self::COMMAND_BUFFER_SUBMIT_INFO => Some("COMMAND_BUFFER_SUBMIT_INFO"),
+            Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES => {
+                Some("PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES")
+            }
+            Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES => {
+                Some("PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES")
+            }
+            Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES => {
+                Some("PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES")
+            }
+            Self::COPY_BUFFER_INFO_2 => Some("COPY_BUFFER_INFO_2"),
+            Self::COPY_IMAGE_INFO_2 => Some("COPY_IMAGE_INFO_2"),
+            Self::COPY_BUFFER_TO_IMAGE_INFO_2 => Some("COPY_BUFFER_TO_IMAGE_INFO_2"),
+            Self::COPY_IMAGE_TO_BUFFER_INFO_2 => Some("COPY_IMAGE_TO_BUFFER_INFO_2"),
+            Self::BLIT_IMAGE_INFO_2 => Some("BLIT_IMAGE_INFO_2"),
+            Self::RESOLVE_IMAGE_INFO_2 => Some("RESOLVE_IMAGE_INFO_2"),
+            Self::BUFFER_COPY_2 => Some("BUFFER_COPY_2"),
+            Self::IMAGE_COPY_2 => Some("IMAGE_COPY_2"),
+            Self::IMAGE_BLIT_2 => Some("IMAGE_BLIT_2"),
+            Self::BUFFER_IMAGE_COPY_2 => Some("BUFFER_IMAGE_COPY_2"),
+            Self::IMAGE_RESOLVE_2 => Some("IMAGE_RESOLVE_2"),
+            Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES => {
+                Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES")
+            }
+            Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO => {
+                Some("PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO")
+            }
+            Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES => {
+                Some("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES")
+            }
+            Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES => {
+                Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES")
+            }
+            Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES => {
+                Some("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES")
+            }
+            Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK => {
+                Some("WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK")
+            }
+            Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO => {
+                Some("DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO")
+            }
+            Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES => {
+                Some("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES")
+            }
+            Self::RENDERING_INFO => Some("RENDERING_INFO"),
+            Self::RENDERING_ATTACHMENT_INFO => Some("RENDERING_ATTACHMENT_INFO"),
+            Self::PIPELINE_RENDERING_CREATE_INFO => Some("PIPELINE_RENDERING_CREATE_INFO"),
+            Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES => {
+                Some("PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES")
+            }
+            Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO => {
+                Some("COMMAND_BUFFER_INHERITANCE_RENDERING_INFO")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES => {
+                Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES")
+            }
+            Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES => {
+                Some("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES")
+            }
+            Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES => {
+                Some("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES")
+            }
+            Self::FORMAT_PROPERTIES_3 => Some("FORMAT_PROPERTIES_3"),
+            Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES => {
+                Some("PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES")
+            }
+            Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES => {
+                Some("PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES")
+            }
+            Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS => Some("DEVICE_BUFFER_MEMORY_REQUIREMENTS"),
+            Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS => Some("DEVICE_IMAGE_MEMORY_REQUIREMENTS"),
             _ => None,
         };
         if let Some(x) = name {
@@ -5157,9 +6380,9 @@ impl fmt::Debug for SubgroupFeatureFlags {
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for SubmitFlagsKHR {
+impl fmt::Debug for SubmitFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[(SubmitFlagsKHR::PROTECTED.0, "PROTECTED")];
+        const KNOWN: &[(Flags, &str)] = &[(SubmitFlags::PROTECTED.0, "PROTECTED")];
         debug_flags(f, KNOWN, self.0)
     }
 }
@@ -5196,10 +6419,56 @@ impl fmt::Debug for SubpassDescriptionFlags {
                 SubpassDescriptionFlags::SHADER_RESOLVE_QCOM.0,
                 "SHADER_RESOLVE_QCOM",
             ),
+            (
+                SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT.0,
+                "RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT",
+            ),
+            (
+                SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT.0,
+                "RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT",
+            ),
+            (
+                SubpassDescriptionFlags::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT.0,
+                "RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT",
+            ),
+            (
+                SubpassDescriptionFlags::ENABLE_LEGACY_DITHERING_EXT.0,
+                "ENABLE_LEGACY_DITHERING_EXT",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for SubpassMergeStatusEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::MERGED => Some("MERGED"),
+            Self::DISALLOWED => Some("DISALLOWED"),
+            Self::NOT_MERGED_SIDE_EFFECTS => Some("NOT_MERGED_SIDE_EFFECTS"),
+            Self::NOT_MERGED_SAMPLES_MISMATCH => Some("NOT_MERGED_SAMPLES_MISMATCH"),
+            Self::NOT_MERGED_VIEWS_MISMATCH => Some("NOT_MERGED_VIEWS_MISMATCH"),
+            Self::NOT_MERGED_ALIASING => Some("NOT_MERGED_ALIASING"),
+            Self::NOT_MERGED_DEPENDENCIES => Some("NOT_MERGED_DEPENDENCIES"),
+            Self::NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT => {
+                Some("NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT")
+            }
+            Self::NOT_MERGED_TOO_MANY_ATTACHMENTS => Some("NOT_MERGED_TOO_MANY_ATTACHMENTS"),
+            Self::NOT_MERGED_INSUFFICIENT_STORAGE => Some("NOT_MERGED_INSUFFICIENT_STORAGE"),
+            Self::NOT_MERGED_DEPTH_STENCIL_COUNT => Some("NOT_MERGED_DEPTH_STENCIL_COUNT"),
+            Self::NOT_MERGED_RESOLVE_ATTACHMENT_REUSE => {
+                Some("NOT_MERGED_RESOLVE_ATTACHMENT_REUSE")
+            }
+            Self::NOT_MERGED_SINGLE_SUBPASS => Some("NOT_MERGED_SINGLE_SUBPASS"),
+            Self::NOT_MERGED_UNSPECIFIED => Some("NOT_MERGED_UNSPECIFIED"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
 impl fmt::Debug for SurfaceCounterFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[(SurfaceCounterFlagsEXT::VBLANK.0, "VBLANK")];
@@ -5243,6 +6512,11 @@ impl fmt::Debug for SwapchainCreateFlagsKHR {
             ),
             (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"),
             (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"),
+            (
+                SwapchainCreateFlagsKHR::DEFERRED_MEMORY_ALLOCATION_EXT.0,
+                "DEFERRED_MEMORY_ALLOCATION_EXT",
+            ),
+            (SwapchainCreateFlagsKHR::RESERVED_4_EXT.0, "RESERVED_4_EXT"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -5300,22 +6574,22 @@ impl fmt::Debug for TimeDomainEXT {
         }
     }
 }
-impl fmt::Debug for ToolPurposeFlagsEXT {
+impl fmt::Debug for ToolPurposeFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (ToolPurposeFlagsEXT::VALIDATION.0, "VALIDATION"),
-            (ToolPurposeFlagsEXT::PROFILING.0, "PROFILING"),
-            (ToolPurposeFlagsEXT::TRACING.0, "TRACING"),
+            (ToolPurposeFlags::VALIDATION.0, "VALIDATION"),
+            (ToolPurposeFlags::PROFILING.0, "PROFILING"),
+            (ToolPurposeFlags::TRACING.0, "TRACING"),
             (
-                ToolPurposeFlagsEXT::ADDITIONAL_FEATURES.0,
+                ToolPurposeFlags::ADDITIONAL_FEATURES.0,
                 "ADDITIONAL_FEATURES",
             ),
+            (ToolPurposeFlags::MODIFYING_FEATURES.0, "MODIFYING_FEATURES"),
             (
-                ToolPurposeFlagsEXT::MODIFYING_FEATURES.0,
-                "MODIFYING_FEATURES",
+                ToolPurposeFlags::DEBUG_REPORTING_EXT.0,
+                "DEBUG_REPORTING_EXT",
             ),
-            (ToolPurposeFlagsEXT::DEBUG_REPORTING.0, "DEBUG_REPORTING"),
-            (ToolPurposeFlagsEXT::DEBUG_MARKERS.0, "DEBUG_MARKERS"),
+            (ToolPurposeFlags::DEBUG_MARKERS_EXT.0, "DEBUG_MARKERS_EXT"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -5399,6 +6673,7 @@ impl fmt::Debug for VendorId {
             Self::CODEPLAY => Some("CODEPLAY"),
             Self::MESA => Some("MESA"),
             Self::POCL => Some("POCL"),
+            Self::MOBILEYE => Some("MOBILEYE"),
             _ => None,
         };
         if let Some(x) = name {
@@ -5464,19 +6739,17 @@ impl fmt::Debug for VideoChromaSubsamplingFlagsKHR {
 impl fmt::Debug for VideoCodecOperationFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (VideoCodecOperationFlagsKHR::INVALID.0, "INVALID"),
+            (VideoCodecOperationFlagsKHR::NONE.0, "NONE"),
             (
                 VideoCodecOperationFlagsKHR::ENCODE_H264_EXT.0,
                 "ENCODE_H264_EXT",
             ),
             (
-                VideoCodecOperationFlagsKHR::DECODE_H264_EXT.0,
-                "DECODE_H264_EXT",
-            ),
-            (
-                VideoCodecOperationFlagsKHR::DECODE_H265_EXT.0,
-                "DECODE_H265_EXT",
+                VideoCodecOperationFlagsKHR::ENCODE_H265_EXT.0,
+                "ENCODE_H265_EXT",
             ),
+            (VideoCodecOperationFlagsKHR::DECODE_H264.0, "DECODE_H264"),
+            (VideoCodecOperationFlagsKHR::DECODE_H265.0, "DECODE_H265"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -5484,18 +6757,15 @@ impl fmt::Debug for VideoCodecOperationFlagsKHR {
 impl fmt::Debug for VideoCodingControlFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (VideoCodingControlFlagsKHR::DEFAULT.0, "DEFAULT"),
             (VideoCodingControlFlagsKHR::RESET.0, "RESET"),
-        ];
-        debug_flags(f, KNOWN, self.0)
-    }
-}
-impl fmt::Debug for VideoCodingQualityPresetFlagsKHR {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[
-            (VideoCodingQualityPresetFlagsKHR::NORMAL.0, "NORMAL"),
-            (VideoCodingQualityPresetFlagsKHR::POWER.0, "POWER"),
-            (VideoCodingQualityPresetFlagsKHR::QUALITY.0, "QUALITY"),
+            (
+                VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL.0,
+                "ENCODE_RATE_CONTROL",
+            ),
+            (
+                VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL_LAYER.0,
+                "ENCODE_RATE_CONTROL_LAYER",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
@@ -5511,67 +6781,124 @@ impl fmt::Debug for VideoComponentBitDepthFlagsKHR {
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoDecodeFlagsKHR {
+impl fmt::Debug for VideoDecodeCapabilityFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (VideoDecodeFlagsKHR::DEFAULT.0, "DEFAULT"),
-            (VideoDecodeFlagsKHR::RESERVED_0.0, "RESERVED_0"),
+            (
+                VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_COINCIDE.0,
+                "DPB_AND_OUTPUT_COINCIDE",
+            ),
+            (
+                VideoDecodeCapabilityFlagsKHR::DPB_AND_OUTPUT_DISTINCT.0,
+                "DPB_AND_OUTPUT_DISTINCT",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoDecodeH264CreateFlagsEXT {
+impl fmt::Debug for VideoDecodeFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoDecodeH264PictureLayoutFlagsEXT {
+impl fmt::Debug for VideoDecodeH264PictureLayoutFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
             (
-                VideoDecodeH264PictureLayoutFlagsEXT::PROGRESSIVE.0,
+                VideoDecodeH264PictureLayoutFlagsKHR::PROGRESSIVE.0,
                 "PROGRESSIVE",
             ),
             (
-                VideoDecodeH264PictureLayoutFlagsEXT::INTERLACED_INTERLEAVED_LINES.0,
+                VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_INTERLEAVED_LINES.0,
                 "INTERLACED_INTERLEAVED_LINES",
             ),
             (
-                VideoDecodeH264PictureLayoutFlagsEXT::INTERLACED_SEPARATE_PLANES.0,
+                VideoDecodeH264PictureLayoutFlagsKHR::INTERLACED_SEPARATE_PLANES.0,
                 "INTERLACED_SEPARATE_PLANES",
             ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoDecodeH265CreateFlagsEXT {
+impl fmt::Debug for VideoDecodeUsageFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[];
+        const KNOWN: &[(Flags, &str)] = &[
+            (VideoDecodeUsageFlagsKHR::DEFAULT.0, "DEFAULT"),
+            (VideoDecodeUsageFlagsKHR::TRANSCODING.0, "TRANSCODING"),
+            (VideoDecodeUsageFlagsKHR::OFFLINE.0, "OFFLINE"),
+            (VideoDecodeUsageFlagsKHR::STREAMING.0, "STREAMING"),
+        ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoEncodeFlagsKHR {
+impl fmt::Debug for VideoEncodeCapabilityFlagsKHR {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[(
+            VideoEncodeCapabilityFlagsKHR::PRECEDING_EXTERNALLY_ENCODED_BYTES.0,
+            "PRECEDING_EXTERNALLY_ENCODED_BYTES",
+        )];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for VideoEncodeContentFlagsKHR {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (VideoEncodeContentFlagsKHR::DEFAULT.0, "DEFAULT"),
+            (VideoEncodeContentFlagsKHR::CAMERA.0, "CAMERA"),
+            (VideoEncodeContentFlagsKHR::DESKTOP.0, "DESKTOP"),
+            (VideoEncodeContentFlagsKHR::RENDERED.0, "RENDERED"),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for VideoEncodeFeedbackFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (VideoEncodeFlagsKHR::DEFAULT.0, "DEFAULT"),
-            (VideoEncodeFlagsKHR::RESERVED_0.0, "RESERVED_0"),
+            (
+                VideoEncodeFeedbackFlagsKHR::BITSTREAM_BUFFER_OFFSET.0,
+                "BITSTREAM_BUFFER_OFFSET",
+            ),
+            (
+                VideoEncodeFeedbackFlagsKHR::BITSTREAM_BYTES_WRITTEN.0,
+                "BITSTREAM_BYTES_WRITTEN",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for VideoEncodeFlagsKHR {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (VideoEncodeH264CapabilityFlagsEXT::CABAC.0, "CABAC"),
-            (VideoEncodeH264CapabilityFlagsEXT::CAVLC.0, "CAVLC"),
             (
-                VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BI_PRED_IMPLICIT.0,
-                "WEIGHTED_BI_PRED_IMPLICIT",
+                VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_ENABLED.0,
+                "DIRECT_8X8_INFERENCE_ENABLED",
             ),
             (
-                VideoEncodeH264CapabilityFlagsEXT::TRANSFORM_8X8.0,
-                "TRANSFORM_8X8",
+                VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_DISABLED.0,
+                "DIRECT_8X8_INFERENCE_DISABLED",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0,
+                "SEPARATE_COLOUR_PLANE",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS.0,
+                "QPPRIME_Y_ZERO_TRANSFORM_BYPASS",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::SCALING_LISTS.0,
+                "SCALING_LISTS",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::HRD_COMPLIANCE.0,
+                "HRD_COMPLIANCE",
             ),
             (
                 VideoEncodeH264CapabilityFlagsEXT::CHROMA_QP_OFFSET.0,
@@ -5582,6 +6909,32 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT {
                 "SECOND_CHROMA_QP_OFFSET",
             ),
             (
+                VideoEncodeH264CapabilityFlagsEXT::PIC_INIT_QP_MINUS26.0,
+                "PIC_INIT_QP_MINUS26",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED.0,
+                "WEIGHTED_PRED",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_EXPLICIT.0,
+                "WEIGHTED_BIPRED_EXPLICIT",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_IMPLICIT.0,
+                "WEIGHTED_BIPRED_IMPLICIT",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0,
+                "WEIGHTED_PRED_NO_TABLE",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::TRANSFORM_8X8.0,
+                "TRANSFORM_8X8",
+            ),
+            (VideoEncodeH264CapabilityFlagsEXT::CABAC.0, "CABAC"),
+            (VideoEncodeH264CapabilityFlagsEXT::CAVLC.0, "CAVLC"),
+            (
                 VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_DISABLED.0,
                 "DEBLOCKING_FILTER_DISABLED",
             ),
@@ -5594,65 +6947,261 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT {
                 "DEBLOCKING_FILTER_PARTIAL",
             ),
             (
+                VideoEncodeH264CapabilityFlagsEXT::DISABLE_DIRECT_SPATIAL_MV_PRED.0,
+                "DISABLE_DIRECT_SPATIAL_MV_PRED",
+            ),
+            (
                 VideoEncodeH264CapabilityFlagsEXT::MULTIPLE_SLICE_PER_FRAME.0,
                 "MULTIPLE_SLICE_PER_FRAME",
             ),
             (
-                VideoEncodeH264CapabilityFlagsEXT::EVENLY_DISTRIBUTED_SLICE_SIZE.0,
-                "EVENLY_DISTRIBUTED_SLICE_SIZE",
+                VideoEncodeH264CapabilityFlagsEXT::SLICE_MB_COUNT.0,
+                "SLICE_MB_COUNT",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::ROW_UNALIGNED_SLICE.0,
+                "ROW_UNALIGNED_SLICE",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0,
+                "DIFFERENT_SLICE_TYPE",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0,
+                "B_FRAME_IN_L1_LIST",
+            ),
+            (
+                VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0,
+                "DIFFERENT_REFERENCE_FINAL_LISTS",
             ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoEncodeH264CreateFlagsEXT {
+impl fmt::Debug for VideoEncodeH264RateControlStructureEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::UNKNOWN => Some("UNKNOWN"),
+            Self::FLAT => Some("FLAT"),
+            Self::DYADIC => Some("DYADIC"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (VideoEncodeH264CreateFlagsEXT::DEFAULT.0, "DEFAULT"),
-            (VideoEncodeH264CreateFlagsEXT::RESERVED_0.0, "RESERVED_0"),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0,
+                "SEPARATE_COLOUR_PLANE",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::SCALING_LISTS.0,
+                "SCALING_LISTS",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED.0,
+                "SAMPLE_ADAPTIVE_OFFSET_ENABLED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::PCM_ENABLE.0,
+                "PCM_ENABLE",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::SPS_TEMPORAL_MVP_ENABLED.0,
+                "SPS_TEMPORAL_MVP_ENABLED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::HRD_COMPLIANCE.0,
+                "HRD_COMPLIANCE",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::INIT_QP_MINUS26.0,
+                "INIT_QP_MINUS26",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0,
+                "LOG2_PARALLEL_MERGE_LEVEL_MINUS2",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::SIGN_DATA_HIDING_ENABLED.0,
+                "SIGN_DATA_HIDING_ENABLED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_ENABLED.0,
+                "TRANSFORM_SKIP_ENABLED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_DISABLED.0,
+                "TRANSFORM_SKIP_DISABLED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT.0,
+                "PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED.0,
+                "WEIGHTED_PRED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_BIPRED.0,
+                "WEIGHTED_BIPRED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0,
+                "WEIGHTED_PRED_NO_TABLE",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::TRANSQUANT_BYPASS_ENABLED.0,
+                "TRANSQUANT_BYPASS_ENABLED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::ENTROPY_CODING_SYNC_ENABLED.0,
+                "ENTROPY_CODING_SYNC_ENABLED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED.0,
+                "DEBLOCKING_FILTER_OVERRIDE_ENABLED",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_FRAME.0,
+                "MULTIPLE_TILE_PER_FRAME",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_PER_TILE.0,
+                "MULTIPLE_SLICE_PER_TILE",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_SLICE.0,
+                "MULTIPLE_TILE_PER_SLICE",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::SLICE_SEGMENT_CTB_COUNT.0,
+                "SLICE_SEGMENT_CTB_COUNT",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::ROW_UNALIGNED_SLICE_SEGMENT.0,
+                "ROW_UNALIGNED_SLICE_SEGMENT",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::DEPENDENT_SLICE_SEGMENT.0,
+                "DEPENDENT_SLICE_SEGMENT",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0,
+                "DIFFERENT_SLICE_TYPE",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0,
+                "B_FRAME_IN_L1_LIST",
+            ),
+            (
+                VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0,
+                "DIFFERENT_REFERENCE_FINAL_LISTS",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoEncodeH264InputModeFlagsEXT {
+impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (VideoEncodeH264InputModeFlagsEXT::FRAME.0, "FRAME"),
-            (VideoEncodeH264InputModeFlagsEXT::SLICE.0, "SLICE"),
-            (VideoEncodeH264InputModeFlagsEXT::NON_VCL.0, "NON_VCL"),
+            (VideoEncodeH265CtbSizeFlagsEXT::TYPE_16.0, "TYPE_16"),
+            (VideoEncodeH265CtbSizeFlagsEXT::TYPE_32.0, "TYPE_32"),
+            (VideoEncodeH265CtbSizeFlagsEXT::TYPE_64.0, "TYPE_64"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
-impl fmt::Debug for VideoEncodeH264OutputModeFlagsEXT {
+impl fmt::Debug for VideoEncodeH265RateControlStructureEXT {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::UNKNOWN => Some("UNKNOWN"),
+            Self::FLAT => Some("FLAT"),
+            Self::DYADIC => Some("DYADIC"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for VideoEncodeH265TransformBlockSizeFlagsEXT {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (VideoEncodeH264OutputModeFlagsEXT::FRAME.0, "FRAME"),
-            (VideoEncodeH264OutputModeFlagsEXT::SLICE.0, "SLICE"),
-            (VideoEncodeH264OutputModeFlagsEXT::NON_VCL.0, "NON_VCL"),
+            (
+                VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_4.0,
+                "TYPE_4",
+            ),
+            (
+                VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_8.0,
+                "TYPE_8",
+            ),
+            (
+                VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_16.0,
+                "TYPE_16",
+            ),
+            (
+                VideoEncodeH265TransformBlockSizeFlagsEXT::TYPE_32.0,
+                "TYPE_32",
+            ),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
 impl fmt::Debug for VideoEncodeRateControlFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[
-            (VideoEncodeRateControlFlagsKHR::DEFAULT.0, "DEFAULT"),
-            (VideoEncodeRateControlFlagsKHR::RESET.0, "RESET"),
-        ];
+        const KNOWN: &[(Flags, &str)] = &[];
         debug_flags(f, KNOWN, self.0)
     }
 }
 impl fmt::Debug for VideoEncodeRateControlModeFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[
-            (VideoEncodeRateControlModeFlagsKHR::NONE.0, "NONE"),
+            (VideoEncodeRateControlModeFlagsKHR::DEFAULT.0, "DEFAULT"),
+            (VideoEncodeRateControlModeFlagsKHR::DISABLED.0, "DISABLED"),
             (VideoEncodeRateControlModeFlagsKHR::CBR.0, "CBR"),
             (VideoEncodeRateControlModeFlagsKHR::VBR.0, "VBR"),
         ];
         debug_flags(f, KNOWN, self.0)
     }
 }
+impl fmt::Debug for VideoEncodeTuningModeKHR {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::DEFAULT => Some("DEFAULT"),
+            Self::HIGH_QUALITY => Some("HIGH_QUALITY"),
+            Self::LOW_LATENCY => Some("LOW_LATENCY"),
+            Self::ULTRA_LOW_LATENCY => Some("ULTRA_LOW_LATENCY"),
+            Self::LOSSLESS => Some("LOSSLESS"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for VideoEncodeUsageFlagsKHR {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[
+            (VideoEncodeUsageFlagsKHR::DEFAULT.0, "DEFAULT"),
+            (VideoEncodeUsageFlagsKHR::TRANSCODING.0, "TRANSCODING"),
+            (VideoEncodeUsageFlagsKHR::STREAMING.0, "STREAMING"),
+            (VideoEncodeUsageFlagsKHR::RECORDING.0, "RECORDING"),
+            (VideoEncodeUsageFlagsKHR::CONFERENCING.0, "CONFERENCING"),
+        ];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
 impl fmt::Debug for VideoEndCodingFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         const KNOWN: &[(Flags, &str)] = &[];
@@ -5661,13 +7210,16 @@ impl fmt::Debug for VideoEndCodingFlagsKHR {
 }
 impl fmt::Debug for VideoSessionCreateFlagsKHR {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        const KNOWN: &[(Flags, &str)] = &[
-            (VideoSessionCreateFlagsKHR::DEFAULT.0, "DEFAULT"),
-            (
-                VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0,
-                "PROTECTED_CONTENT",
-            ),
-        ];
+        const KNOWN: &[(Flags, &str)] = &[(
+            VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0,
+            "PROTECTED_CONTENT",
+        )];
+        debug_flags(f, KNOWN, self.0)
+    }
+}
+impl fmt::Debug for VideoSessionParametersCreateFlagsKHR {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        const KNOWN: &[(Flags, &str)] = &[];
         debug_flags(f, KNOWN, self.0)
     }
 }
diff --git a/src/vk/constants.rs b/src/vk/constants.rs
index 95a976e..384e28a 100644
--- a/src/vk/constants.rs
+++ b/src/vk/constants.rs
@@ -5,10 +5,12 @@ pub const LUID_SIZE: usize = 8;
 pub const MAX_EXTENSION_NAME_SIZE: usize = 256;
 pub const MAX_DESCRIPTION_SIZE: usize = 256;
 pub const MAX_MEMORY_TYPES: usize = 32;
+#[doc = "The maximum number of unique memory heaps, each of which supporting 1 or more memory types"]
 pub const MAX_MEMORY_HEAPS: usize = 16;
 pub const LOD_CLAMP_NONE: f32 = 1000.00;
 pub const REMAINING_MIP_LEVELS: u32 = !0;
 pub const REMAINING_ARRAY_LAYERS: u32 = !0;
+pub const REMAINING_3D_SLICES_EXT: u32 = !0;
 pub const WHOLE_SIZE: u64 = !0;
 pub const ATTACHMENT_UNUSED: u32 = !0;
 pub const TRUE: Bool32 = 1;
@@ -21,5 +23,6 @@ pub const MAX_DEVICE_GROUP_SIZE: usize = 32;
 pub const MAX_DRIVER_NAME_SIZE: usize = 256;
 pub const MAX_DRIVER_INFO_SIZE: usize = 256;
 pub const SHADER_UNUSED_KHR: u32 = !0;
-pub const MAX_GLOBAL_PRIORITY_SIZE_EXT: usize = 16;
+pub const MAX_GLOBAL_PRIORITY_SIZE_KHR: usize = 16;
+pub const MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: usize = 32;
 pub const SHADER_UNUSED_NV: u32 = SHADER_UNUSED_KHR;
diff --git a/src/vk/definitions.rs b/src/vk/definitions.rs
index 5dbba8f..6961285 100644
--- a/src/vk/definitions.rs
+++ b/src/vk/definitions.rs
@@ -4,450 +4,460 @@ use crate::vk::constants::*;
 use crate::vk::enums::*;
 use crate::vk::native::*;
 use crate::vk::platform_types::*;
+use crate::vk::prelude::*;
 use crate::vk::{ptr_chain_iter, Handle};
 use std::fmt;
 use std::os::raw::*;
 #[deprecated = "This define is deprecated. VK_MAKE_API_VERSION should be used instead."]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_MAKE_VERSION.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_MAKE_VERSION.html>"]
 pub const fn make_version(major: u32, minor: u32, patch: u32) -> u32 {
     ((major) << 22) | ((minor) << 12) | (patch)
 }
 #[deprecated = "This define is deprecated. VK_API_VERSION_MAJOR should be used instead."]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VERSION_MAJOR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_MAJOR.html>"]
 pub const fn version_major(version: u32) -> u32 {
     (version) >> 22
 }
 #[deprecated = "This define is deprecated. VK_API_VERSION_MINOR should be used instead."]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VERSION_MINOR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_MINOR.html>"]
 pub const fn version_minor(version: u32) -> u32 {
     ((version) >> 12) & 0x3ffu32
 }
 #[deprecated = "This define is deprecated. VK_API_VERSION_PATCH should be used instead."]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_VERSION_PATCH.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_VERSION_PATCH.html>"]
 pub const fn version_patch(version: u32) -> u32 {
     (version) & 0xfffu32
 }
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_MAKE_API_VERSION.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_MAKE_API_VERSION.html>"]
 pub const fn make_api_version(variant: u32, major: u32, minor: u32, patch: u32) -> u32 {
     ((variant) << 29) | ((major) << 22) | ((minor) << 12) | (patch)
 }
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_API_VERSION_VARIANT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_VARIANT.html>"]
 pub const fn api_version_variant(version: u32) -> u32 {
     (version) >> 29
 }
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_API_VERSION_MAJOR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_MAJOR.html>"]
 pub const fn api_version_major(version: u32) -> u32 {
     ((version) >> 22) & 0x7fu32
 }
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_API_VERSION_MINOR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_MINOR.html>"]
 pub const fn api_version_minor(version: u32) -> u32 {
     ((version) >> 12) & 0x3ffu32
 }
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_API_VERSION_PATCH.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_PATCH.html>"]
 pub const fn api_version_patch(version: u32) -> u32 {
     (version) & 0xfffu32
 }
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_API_VERSION_1_0.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_0.html>"]
 pub const API_VERSION_1_0: u32 = make_api_version(0, 1, 0, 0);
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_API_VERSION_1_1.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_1.html>"]
 pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0);
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_API_VERSION_1_2.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_2.html>"]
 pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0);
-pub const HEADER_VERSION: u32 = 191u32;
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VK_HEADER_VERSION_COMPLETE.html>"]
-pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 2, HEADER_VERSION);
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleMask.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_API_VERSION_1_3.html>"]
+pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0);
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION.html>"]
+pub const HEADER_VERSION: u32 = 251;
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VK_HEADER_VERSION_COMPLETE.html>"]
+pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION);
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleMask.html>"]
 pub type SampleMask = u32;
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBool32.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBool32.html>"]
 pub type Bool32 = u32;
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags.html>"]
 pub type Flags = u32;
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFlags64.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFlags64.html>"]
 pub type Flags64 = u64;
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceSize.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceSize.html>"]
 pub type DeviceSize = u64;
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceAddress.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddress.html>"]
 pub type DeviceAddress = u64;
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateFlags.html>"]
 pub struct QueryPoolCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(QueryPoolCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(QueryPoolCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDepthStencilStateCreateFlags.html>"]
-pub struct PipelineDepthStencilStateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineDepthStencilStateCreateFlags, 0b0, Flags);
-#[repr(transparent)]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDynamicStateCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateFlags.html>"]
 pub struct PipelineDynamicStateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, 0b0, Flags);
-#[repr(transparent)]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendStateCreateFlags.html>"]
-pub struct PipelineColorBlendStateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineColorBlendStateCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineDynamicStateCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateFlags.html>"]
 pub struct PipelineMultisampleStateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineMultisampleStateCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateFlags.html>"]
 pub struct PipelineRasterizationStateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineRasterizationStateCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportStateCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateFlags.html>"]
 pub struct PipelineViewportStateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineViewportStateCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationStateCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateFlags.html>"]
 pub struct PipelineTessellationStateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineTessellationStateCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateFlags.html>"]
 pub struct PipelineInputAssemblyStateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineInputAssemblyStateCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateFlags.html>"]
 pub struct PipelineVertexInputStateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineVertexInputStateCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferViewCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateFlags.html>"]
 pub struct BufferViewCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(BufferViewCreateFlags, 0b0, Flags);
-#[repr(transparent)]
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstanceCreateFlags.html>"]
-pub struct InstanceCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(InstanceCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(BufferViewCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateFlags.html>"]
 pub struct DeviceCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(DeviceCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(DeviceCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryMapFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryMapFlags.html>"]
 pub struct MemoryMapFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(MemoryMapFlags, 0b0, Flags);
+vk_bitflags_wrapped!(MemoryMapFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolResetFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolResetFlags.html>"]
 pub struct DescriptorPoolResetFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(DescriptorPoolResetFlags, 0b0, Flags);
+vk_bitflags_wrapped!(DescriptorPoolResetFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateFlags.html>"]
 pub struct DescriptorUpdateTemplateCreateFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, 0b0, Flags);
+vk_bitflags_wrapped!(DescriptorUpdateTemplateCreateFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInfoFlagsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoFlagsNV.html>"]
 pub struct AccelerationStructureMotionInfoFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, 0b0, Flags);
+vk_bitflags_wrapped!(AccelerationStructureMotionInfoFlagsNV, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html>"]
 pub struct AccelerationStructureMotionInstanceFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, 0b0, Flags);
+vk_bitflags_wrapped!(AccelerationStructureMotionInstanceFlagsNV, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeCreateFlagsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingFlagsLUNARG.html>"]
+pub struct DirectDriverLoadingFlagsLUNARG(pub(crate) Flags);
+vk_bitflags_wrapped!(DirectDriverLoadingFlagsLUNARG, Flags);
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateFlagsKHR.html>"]
 pub struct DisplayModeCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(DisplayModeCreateFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateFlagsKHR.html>"]
 pub struct DisplaySurfaceCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(DisplaySurfaceCreateFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidSurfaceCreateFlagsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidSurfaceCreateFlagsKHR.html>"]
 pub struct AndroidSurfaceCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(AndroidSurfaceCreateFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViSurfaceCreateFlagsNN.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViSurfaceCreateFlagsNN.html>"]
 pub struct ViSurfaceCreateFlagsNN(pub(crate) Flags);
-vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, 0b0, Flags);
+vk_bitflags_wrapped!(ViSurfaceCreateFlagsNN, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWaylandSurfaceCreateFlagsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWaylandSurfaceCreateFlagsKHR.html>"]
 pub struct WaylandSurfaceCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(WaylandSurfaceCreateFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateFlagsKHR.html>"]
 pub struct Win32SurfaceCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(Win32SurfaceCreateFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXlibSurfaceCreateFlagsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXlibSurfaceCreateFlagsKHR.html>"]
 pub struct XlibSurfaceCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(XlibSurfaceCreateFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXcbSurfaceCreateFlagsKHR.html>"]
 pub struct XcbSurfaceCreateFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(XcbSurfaceCreateFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDirectFBSurfaceCreateFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectFBSurfaceCreateFlagsEXT.html>"]
 pub struct DirectFBSurfaceCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, 0b0, Flags);
+vk_bitflags_wrapped!(DirectFBSurfaceCreateFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIOSSurfaceCreateFlagsMVK.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIOSSurfaceCreateFlagsMVK.html>"]
 pub struct IOSSurfaceCreateFlagsMVK(pub(crate) Flags);
-vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, 0b0, Flags);
+vk_bitflags_wrapped!(IOSSurfaceCreateFlagsMVK, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateFlagsMVK.html>"]
 pub struct MacOSSurfaceCreateFlagsMVK(pub(crate) Flags);
-vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, 0b0, Flags);
+vk_bitflags_wrapped!(MacOSSurfaceCreateFlagsMVK, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateFlagsEXT.html>"]
 pub struct MetalSurfaceCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, 0b0, Flags);
+vk_bitflags_wrapped!(MetalSurfaceCreateFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html>"]
 pub struct ImagePipeSurfaceCreateFlagsFUCHSIA(pub(crate) Flags);
-vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, 0b0, Flags);
+vk_bitflags_wrapped!(ImagePipeSurfaceCreateFlagsFUCHSIA, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html>"]
 pub struct StreamDescriptorSurfaceCreateFlagsGGP(pub(crate) Flags);
-vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, 0b0, Flags);
+vk_bitflags_wrapped!(StreamDescriptorSurfaceCreateFlagsGGP, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateFlagsEXT.html>"]
 pub struct HeadlessSurfaceCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, 0b0, Flags);
+vk_bitflags_wrapped!(HeadlessSurfaceCreateFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkScreenSurfaceCreateFlagsQNX.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkScreenSurfaceCreateFlagsQNX.html>"]
 pub struct ScreenSurfaceCreateFlagsQNX(pub(crate) Flags);
-vk_bitflags_wrapped!(ScreenSurfaceCreateFlagsQNX, 0b0, Flags);
+vk_bitflags_wrapped!(ScreenSurfaceCreateFlagsQNX, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolTrimFlags.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolTrimFlags.html>"]
 pub struct CommandPoolTrimFlags(pub(crate) Flags);
-vk_bitflags_wrapped!(CommandPoolTrimFlags, 0b0, Flags);
+vk_bitflags_wrapped!(CommandPoolTrimFlags, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html>"]
 pub struct PipelineViewportSwizzleStateCreateFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineViewportSwizzleStateCreateFlagsNV, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html>"]
 pub struct PipelineDiscardRectangleStateCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineDiscardRectangleStateCreateFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html>"]
 pub struct PipelineCoverageToColorStateCreateFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineCoverageToColorStateCreateFlagsNV, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html>"]
 pub struct PipelineCoverageModulationStateCreateFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineCoverageModulationStateCreateFlagsNV, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html>"]
 pub struct PipelineCoverageReductionStateCreateFlagsNV(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineCoverageReductionStateCreateFlagsNV, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheCreateFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateFlagsEXT.html>"]
 pub struct ValidationCacheCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, 0b0, Flags);
+vk_bitflags_wrapped!(ValidationCacheCreateFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html>"]
 pub struct DebugUtilsMessengerCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, 0b0, Flags);
+vk_bitflags_wrapped!(DebugUtilsMessengerCreateFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html>"]
 pub struct DebugUtilsMessengerCallbackDataFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, 0b0, Flags);
+vk_bitflags_wrapped!(DebugUtilsMessengerCallbackDataFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryReportFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportFlagsEXT.html>"]
 pub struct DeviceMemoryReportFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, 0b0, Flags);
+vk_bitflags_wrapped!(DeviceMemoryReportFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html>"]
 pub struct PipelineRasterizationConservativeStateCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(
-    PipelineRasterizationConservativeStateCreateFlagsEXT,
-    0b0,
-    Flags
-);
+vk_bitflags_wrapped!(PipelineRasterizationConservativeStateCreateFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html>"]
 pub struct PipelineRasterizationStateStreamCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, 0b0, Flags);
+vk_bitflags_wrapped!(PipelineRasterizationStateStreamCreateFlagsEXT, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html>"]
 pub struct PipelineRasterizationDepthClipStateCreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(
-    PipelineRasterizationDepthClipStateCreateFlagsEXT,
-    0b0,
-    Flags
-);
+vk_bitflags_wrapped!(PipelineRasterizationDepthClipStateCreateFlagsEXT, Flags);
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateFlagsKHR.html>"]
+pub struct VideoSessionParametersCreateFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoSessionParametersCreateFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoBeginCodingFlagsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingFlagsKHR.html>"]
 pub struct VideoBeginCodingFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(VideoBeginCodingFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEndCodingFlagsKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingFlagsKHR.html>"]
 pub struct VideoEndCodingFlagsKHR(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, 0b0, Flags);
+vk_bitflags_wrapped!(VideoEndCodingFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264CreateFlagsEXT.html>"]
-pub struct VideoDecodeH264CreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoDecodeH264CreateFlagsEXT, 0b0, Flags);
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeFlagsKHR.html>"]
+pub struct VideoDecodeFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoDecodeFlagsKHR, Flags);
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265CreateFlagsEXT.html>"]
-pub struct VideoDecodeH265CreateFlagsEXT(pub(crate) Flags);
-vk_bitflags_wrapped!(VideoDecodeH265CreateFlagsEXT, 0b0, Flags);
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeFlagsKHR.html>"]
+pub struct VideoEncodeFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeFlagsKHR, Flags);
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlFlagsKHR.html>"]
+pub struct VideoEncodeRateControlFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(VideoEncodeRateControlFlagsKHR, Flags);
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryUnmapFlagsKHR.html>"]
+pub struct MemoryUnmapFlagsKHR(pub(crate) Flags);
+vk_bitflags_wrapped!(MemoryUnmapFlagsKHR, Flags);
 define_handle!(
     Instance,
     INSTANCE,
-    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstance.html>"
+    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstance.html>"
 );
-define_handle ! (PhysicalDevice , PHYSICAL_DEVICE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice.html>") ;
+define_handle ! (PhysicalDevice , PHYSICAL_DEVICE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice.html>") ;
 define_handle!(
     Device,
     DEVICE,
-    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDevice.html>"
+    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevice.html>"
 );
 define_handle!(
     Queue,
     QUEUE,
-    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueue.html>"
+    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueue.html>"
 );
-define_handle ! (CommandBuffer , COMMAND_BUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBuffer.html>") ;
-handle_nondispatchable ! (DeviceMemory , DEVICE_MEMORY , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemory.html>") ;
-handle_nondispatchable ! (CommandPool , COMMAND_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPool.html>") ;
+define_handle ! (CommandBuffer , COMMAND_BUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBuffer.html>") ;
+handle_nondispatchable ! (DeviceMemory , DEVICE_MEMORY , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemory.html>") ;
+handle_nondispatchable ! (CommandPool , COMMAND_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPool.html>") ;
 handle_nondispatchable!(
     Buffer,
     BUFFER,
-    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuffer.html>"
+    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuffer.html>"
 );
 handle_nondispatchable!(
     BufferView,
     BUFFER_VIEW,
     doc =
-        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferView.html>"
+        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferView.html>"
 );
 handle_nondispatchable!(
     Image,
     IMAGE,
-    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImage.html>"
+    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImage.html>"
 );
 handle_nondispatchable!(
     ImageView,
     IMAGE_VIEW,
     doc =
-        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageView.html>"
+        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageView.html>"
 );
-handle_nondispatchable ! (ShaderModule , SHADER_MODULE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModule.html>") ;
+handle_nondispatchable ! (ShaderModule , SHADER_MODULE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModule.html>") ;
 handle_nondispatchable!(
     Pipeline,
     PIPELINE,
-    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipeline.html>"
+    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipeline.html>"
 );
-handle_nondispatchable ! (PipelineLayout , PIPELINE_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayout.html>") ;
+handle_nondispatchable ! (PipelineLayout , PIPELINE_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayout.html>") ;
 handle_nondispatchable!(
     Sampler,
     SAMPLER,
-    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampler.html>"
+    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampler.html>"
 );
-handle_nondispatchable ! (DescriptorSet , DESCRIPTOR_SET , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSet.html>") ;
-handle_nondispatchable ! (DescriptorSetLayout , DESCRIPTOR_SET_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayout.html>") ;
-handle_nondispatchable ! (DescriptorPool , DESCRIPTOR_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPool.html>") ;
+handle_nondispatchable ! (DescriptorSet , DESCRIPTOR_SET , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSet.html>") ;
+handle_nondispatchable ! (DescriptorSetLayout , DESCRIPTOR_SET_LAYOUT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayout.html>") ;
+handle_nondispatchable ! (DescriptorPool , DESCRIPTOR_POOL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPool.html>") ;
 handle_nondispatchable!(
     Fence,
     FENCE,
-    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFence.html>"
+    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFence.html>"
 );
 handle_nondispatchable!(
     Semaphore,
     SEMAPHORE,
     doc =
-        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphore.html>"
+        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphore.html>"
 );
 handle_nondispatchable!(
     Event,
     EVENT,
-    doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEvent.html>"
+    doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEvent.html>"
 );
 handle_nondispatchable!(
     QueryPool,
     QUERY_POOL,
     doc =
-        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPool.html>"
+        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPool.html>"
 );
-handle_nondispatchable ! (Framebuffer , FRAMEBUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebuffer.html>") ;
+handle_nondispatchable ! (Framebuffer , FRAMEBUFFER , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebuffer.html>") ;
 handle_nondispatchable!(
     RenderPass,
     RENDER_PASS,
     doc =
-        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPass.html>"
+        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPass.html>"
+);
+handle_nondispatchable ! (PipelineCache , PIPELINE_CACHE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCache.html>") ;
+handle_nondispatchable ! (IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutNV.html>") ;
+handle_nondispatchable ! (DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplate.html>") ;
+handle_nondispatchable ! (SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversion.html>") ;
+handle_nondispatchable ! (ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheEXT.html>") ;
+handle_nondispatchable ! (AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureKHR.html>") ;
+handle_nondispatchable ! (AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureNV.html>") ;
+handle_nondispatchable ! (PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationINTEL.html>") ;
+handle_nondispatchable ! (BufferCollectionFUCHSIA , BUFFER_COLLECTION_FUCHSIA , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionFUCHSIA.html>") ;
+handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeferredOperationKHR.html>") ;
+handle_nondispatchable ! (PrivateDataSlot , PRIVATE_DATA_SLOT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlot.html>") ;
+handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleNVX.html>") ;
+handle_nondispatchable ! (CuFunctionNVX , CU_FUNCTION_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionNVX.html>") ;
+handle_nondispatchable ! (OpticalFlowSessionNV , OPTICAL_FLOW_SESSION_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionNV.html>") ;
+handle_nondispatchable ! (MicromapEXT , MICROMAP_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapEXT.html>") ;
+handle_nondispatchable!(
+    ShaderEXT,
+    SHADER_EXT,
+    doc =
+        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderEXT.html>"
 );
-handle_nondispatchable ! (PipelineCache , PIPELINE_CACHE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCache.html>") ;
-handle_nondispatchable ! (IndirectCommandsLayoutNV , INDIRECT_COMMANDS_LAYOUT_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutNV.html>") ;
-handle_nondispatchable ! (DescriptorUpdateTemplate , DESCRIPTOR_UPDATE_TEMPLATE , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplate.html>") ;
-handle_nondispatchable ! (SamplerYcbcrConversion , SAMPLER_YCBCR_CONVERSION , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversion.html>") ;
-handle_nondispatchable ! (ValidationCacheEXT , VALIDATION_CACHE_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheEXT.html>") ;
-handle_nondispatchable ! (AccelerationStructureKHR , ACCELERATION_STRUCTURE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureKHR.html>") ;
-handle_nondispatchable ! (AccelerationStructureNV , ACCELERATION_STRUCTURE_NV , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureNV.html>") ;
-handle_nondispatchable ! (PerformanceConfigurationINTEL , PERFORMANCE_CONFIGURATION_INTEL , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceConfigurationINTEL.html>") ;
-handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeferredOperationKHR.html>") ;
-handle_nondispatchable ! (PrivateDataSlotEXT , PRIVATE_DATA_SLOT_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPrivateDataSlotEXT.html>") ;
-handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCuModuleNVX.html>") ;
-handle_nondispatchable ! (CuFunctionNVX , CU_FUNCTION_NVX , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCuFunctionNVX.html>") ;
 handle_nondispatchable!(
     DisplayKHR,
     DISPLAY_KHR,
     doc =
-        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayKHR.html>"
+        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayKHR.html>"
 );
-handle_nondispatchable ! (DisplayModeKHR , DISPLAY_MODE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeKHR.html>") ;
+handle_nondispatchable ! (DisplayModeKHR , DISPLAY_MODE_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeKHR.html>") ;
 handle_nondispatchable!(
     SurfaceKHR,
     SURFACE_KHR,
     doc =
-        "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceKHR.html>"
+        "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html>"
 );
-handle_nondispatchable ! (SwapchainKHR , SWAPCHAIN_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainKHR.html>") ;
-handle_nondispatchable ! (DebugReportCallbackEXT , DEBUG_REPORT_CALLBACK_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportCallbackEXT.html>") ;
-handle_nondispatchable ! (DebugUtilsMessengerEXT , DEBUG_UTILS_MESSENGER_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerEXT.html>") ;
-handle_nondispatchable ! (VideoSessionKHR , VIDEO_SESSION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionKHR.html>") ;
-handle_nondispatchable ! (VideoSessionParametersKHR , VIDEO_SESSION_PARAMETERS_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionParametersKHR.html>") ;
+handle_nondispatchable ! (SwapchainKHR , SWAPCHAIN_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainKHR.html>") ;
+handle_nondispatchable ! (DebugReportCallbackEXT , DEBUG_REPORT_CALLBACK_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackEXT.html>") ;
+handle_nondispatchable ! (DebugUtilsMessengerEXT , DEBUG_UTILS_MESSENGER_EXT , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerEXT.html>") ;
+handle_nondispatchable ! (VideoSessionKHR , VIDEO_SESSION_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionKHR.html>") ;
+handle_nondispatchable ! (VideoSessionParametersKHR , VIDEO_SESSION_PARAMETERS_KHR , doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersKHR.html>") ;
 #[allow(non_camel_case_types)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkInternalAllocationNotification.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalAllocationNotification.html>"]
 pub type PFN_vkInternalAllocationNotification = Option<
     unsafe extern "system" fn(
         p_user_data: *mut c_void,
@@ -457,7 +467,7 @@ pub type PFN_vkInternalAllocationNotification = Option<
     ),
 >;
 #[allow(non_camel_case_types)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkInternalFreeNotification.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkInternalFreeNotification.html>"]
 pub type PFN_vkInternalFreeNotification = Option<
     unsafe extern "system" fn(
         p_user_data: *mut c_void,
@@ -467,7 +477,7 @@ pub type PFN_vkInternalFreeNotification = Option<
     ),
 >;
 #[allow(non_camel_case_types)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkReallocationFunction.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkReallocationFunction.html>"]
 pub type PFN_vkReallocationFunction = Option<
     unsafe extern "system" fn(
         p_user_data: *mut c_void,
@@ -478,7 +488,7 @@ pub type PFN_vkReallocationFunction = Option<
     ) -> *mut c_void,
 >;
 #[allow(non_camel_case_types)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkAllocationFunction.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkAllocationFunction.html>"]
 pub type PFN_vkAllocationFunction = Option<
     unsafe extern "system" fn(
         p_user_data: *mut c_void,
@@ -488,14 +498,14 @@ pub type PFN_vkAllocationFunction = Option<
     ) -> *mut c_void,
 >;
 #[allow(non_camel_case_types)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkFreeFunction.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkFreeFunction.html>"]
 pub type PFN_vkFreeFunction =
     Option<unsafe extern "system" fn(p_user_data: *mut c_void, p_memory: *mut c_void)>;
 #[allow(non_camel_case_types)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkVoidFunction.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkVoidFunction.html>"]
 pub type PFN_vkVoidFunction = Option<unsafe extern "system" fn()>;
 #[allow(non_camel_case_types)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkDebugReportCallbackEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugReportCallbackEXT.html>"]
 pub type PFN_vkDebugReportCallbackEXT = Option<
     unsafe extern "system" fn(
         flags: DebugReportFlagsEXT,
@@ -509,7 +519,7 @@ pub type PFN_vkDebugReportCallbackEXT = Option<
     ) -> Bool32,
 >;
 #[allow(non_camel_case_types)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkDebugUtilsMessengerCallbackEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDebugUtilsMessengerCallbackEXT.html>"]
 pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<
     unsafe extern "system" fn(
         message_severity: DebugUtilsMessageSeverityFlagsEXT,
@@ -519,46 +529,56 @@ pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<
     ) -> Bool32,
 >;
 #[allow(non_camel_case_types)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/PFN_vkDeviceMemoryReportCallbackEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkDeviceMemoryReportCallbackEXT.html>"]
 pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<
     unsafe extern "system" fn(
         p_callback_data: *const DeviceMemoryReportCallbackDataEXT,
         p_user_data: *mut c_void,
     ),
 >;
+#[allow(non_camel_case_types)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/PFN_vkGetInstanceProcAddrLUNARG.html>"]
+pub type PFN_vkGetInstanceProcAddrLUNARG = Option<
+    unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction,
+>;
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBaseOutStructure.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseOutStructure.html>"]
 pub struct BaseOutStructure {
     pub s_type: StructureType,
-    pub p_next: *mut BaseOutStructure,
+    pub p_next: *mut Self,
 }
 impl ::std::default::Default for BaseOutStructure {
-    fn default() -> BaseOutStructure {
-        BaseOutStructure {
+    #[inline]
+    fn default() -> Self {
+        Self {
             s_type: unsafe { ::std::mem::zeroed() },
             p_next: ::std::ptr::null_mut(),
         }
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBaseInStructure.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBaseInStructure.html>"]
 pub struct BaseInStructure {
     pub s_type: StructureType,
-    pub p_next: *const BaseInStructure,
+    pub p_next: *const Self,
 }
 impl ::std::default::Default for BaseInStructure {
-    fn default() -> BaseInStructure {
-        BaseInStructure {
+    #[inline]
+    fn default() -> Self {
+        Self {
             s_type: unsafe { ::std::mem::zeroed() },
             p_next: ::std::ptr::null(),
         }
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkOffset2D.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset2D.html>"]
 pub struct Offset2D {
     pub x: i32,
     pub y: i32,
@@ -566,7 +586,7 @@ pub struct Offset2D {
 impl Offset2D {
     pub fn builder<'a>() -> Offset2DBuilder<'a> {
         Offset2DBuilder {
-            inner: Offset2D::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -588,10 +608,12 @@ impl<'a> ::std::ops::DerefMut for Offset2DBuilder<'a> {
     }
 }
 impl<'a> Offset2DBuilder<'a> {
+    #[inline]
     pub fn x(mut self, x: i32) -> Self {
         self.inner.x = x;
         self
     }
+    #[inline]
     pub fn y(mut self, y: i32) -> Self {
         self.inner.y = y;
         self
@@ -604,8 +626,9 @@ impl<'a> Offset2DBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkOffset3D.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOffset3D.html>"]
 pub struct Offset3D {
     pub x: i32,
     pub y: i32,
@@ -614,7 +637,7 @@ pub struct Offset3D {
 impl Offset3D {
     pub fn builder<'a>() -> Offset3DBuilder<'a> {
         Offset3DBuilder {
-            inner: Offset3D::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -636,14 +659,17 @@ impl<'a> ::std::ops::DerefMut for Offset3DBuilder<'a> {
     }
 }
 impl<'a> Offset3DBuilder<'a> {
+    #[inline]
     pub fn x(mut self, x: i32) -> Self {
         self.inner.x = x;
         self
     }
+    #[inline]
     pub fn y(mut self, y: i32) -> Self {
         self.inner.y = y;
         self
     }
+    #[inline]
     pub fn z(mut self, z: i32) -> Self {
         self.inner.z = z;
         self
@@ -656,8 +682,9 @@ impl<'a> Offset3DBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExtent2D.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent2D.html>"]
 pub struct Extent2D {
     pub width: u32,
     pub height: u32,
@@ -665,7 +692,7 @@ pub struct Extent2D {
 impl Extent2D {
     pub fn builder<'a>() -> Extent2DBuilder<'a> {
         Extent2DBuilder {
-            inner: Extent2D::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -687,10 +714,12 @@ impl<'a> ::std::ops::DerefMut for Extent2DBuilder<'a> {
     }
 }
 impl<'a> Extent2DBuilder<'a> {
+    #[inline]
     pub fn width(mut self, width: u32) -> Self {
         self.inner.width = width;
         self
     }
+    #[inline]
     pub fn height(mut self, height: u32) -> Self {
         self.inner.height = height;
         self
@@ -703,8 +732,9 @@ impl<'a> Extent2DBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExtent3D.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtent3D.html>"]
 pub struct Extent3D {
     pub width: u32,
     pub height: u32,
@@ -713,7 +743,7 @@ pub struct Extent3D {
 impl Extent3D {
     pub fn builder<'a>() -> Extent3DBuilder<'a> {
         Extent3DBuilder {
-            inner: Extent3D::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -735,14 +765,17 @@ impl<'a> ::std::ops::DerefMut for Extent3DBuilder<'a> {
     }
 }
 impl<'a> Extent3DBuilder<'a> {
+    #[inline]
     pub fn width(mut self, width: u32) -> Self {
         self.inner.width = width;
         self
     }
+    #[inline]
     pub fn height(mut self, height: u32) -> Self {
         self.inner.height = height;
         self
     }
+    #[inline]
     pub fn depth(mut self, depth: u32) -> Self {
         self.inner.depth = depth;
         self
@@ -755,8 +788,9 @@ impl<'a> Extent3DBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewport.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewport.html>"]
 pub struct Viewport {
     pub x: f32,
     pub y: f32,
@@ -768,7 +802,7 @@ pub struct Viewport {
 impl Viewport {
     pub fn builder<'a>() -> ViewportBuilder<'a> {
         ViewportBuilder {
-            inner: Viewport::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -790,26 +824,32 @@ impl<'a> ::std::ops::DerefMut for ViewportBuilder<'a> {
     }
 }
 impl<'a> ViewportBuilder<'a> {
+    #[inline]
     pub fn x(mut self, x: f32) -> Self {
         self.inner.x = x;
         self
     }
+    #[inline]
     pub fn y(mut self, y: f32) -> Self {
         self.inner.y = y;
         self
     }
+    #[inline]
     pub fn width(mut self, width: f32) -> Self {
         self.inner.width = width;
         self
     }
+    #[inline]
     pub fn height(mut self, height: f32) -> Self {
         self.inner.height = height;
         self
     }
+    #[inline]
     pub fn min_depth(mut self, min_depth: f32) -> Self {
         self.inner.min_depth = min_depth;
         self
     }
+    #[inline]
     pub fn max_depth(mut self, max_depth: f32) -> Self {
         self.inner.max_depth = max_depth;
         self
@@ -822,8 +862,9 @@ impl<'a> ViewportBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRect2D.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRect2D.html>"]
 pub struct Rect2D {
     pub offset: Offset2D,
     pub extent: Extent2D,
@@ -831,7 +872,7 @@ pub struct Rect2D {
 impl Rect2D {
     pub fn builder<'a>() -> Rect2DBuilder<'a> {
         Rect2DBuilder {
-            inner: Rect2D::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -853,10 +894,12 @@ impl<'a> ::std::ops::DerefMut for Rect2DBuilder<'a> {
     }
 }
 impl<'a> Rect2DBuilder<'a> {
+    #[inline]
     pub fn offset(mut self, offset: Offset2D) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn extent(mut self, extent: Extent2D) -> Self {
         self.inner.extent = extent;
         self
@@ -869,8 +912,9 @@ impl<'a> Rect2DBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearRect.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearRect.html>"]
 pub struct ClearRect {
     pub rect: Rect2D,
     pub base_array_layer: u32,
@@ -879,7 +923,7 @@ pub struct ClearRect {
 impl ClearRect {
     pub fn builder<'a>() -> ClearRectBuilder<'a> {
         ClearRectBuilder {
-            inner: ClearRect::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -901,14 +945,17 @@ impl<'a> ::std::ops::DerefMut for ClearRectBuilder<'a> {
     }
 }
 impl<'a> ClearRectBuilder<'a> {
+    #[inline]
     pub fn rect(mut self, rect: Rect2D) -> Self {
         self.inner.rect = rect;
         self
     }
+    #[inline]
     pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
         self.inner.base_array_layer = base_array_layer;
         self
     }
+    #[inline]
     pub fn layer_count(mut self, layer_count: u32) -> Self {
         self.inner.layer_count = layer_count;
         self
@@ -921,8 +968,9 @@ impl<'a> ClearRectBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkComponentMapping.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComponentMapping.html>"]
 pub struct ComponentMapping {
     pub r: ComponentSwizzle,
     pub g: ComponentSwizzle,
@@ -932,7 +980,7 @@ pub struct ComponentMapping {
 impl ComponentMapping {
     pub fn builder<'a>() -> ComponentMappingBuilder<'a> {
         ComponentMappingBuilder {
-            inner: ComponentMapping::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -954,18 +1002,22 @@ impl<'a> ::std::ops::DerefMut for ComponentMappingBuilder<'a> {
     }
 }
 impl<'a> ComponentMappingBuilder<'a> {
+    #[inline]
     pub fn r(mut self, r: ComponentSwizzle) -> Self {
         self.inner.r = r;
         self
     }
+    #[inline]
     pub fn g(mut self, g: ComponentSwizzle) -> Self {
         self.inner.g = g;
         self
     }
+    #[inline]
     pub fn b(mut self, b: ComponentSwizzle) -> Self {
         self.inner.b = b;
         self
     }
+    #[inline]
     pub fn a(mut self, a: ComponentSwizzle) -> Self {
         self.inner.a = a;
         self
@@ -979,7 +1031,7 @@ impl<'a> ComponentMappingBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties.html>"]
 pub struct PhysicalDeviceProperties {
     pub api_version: u32,
     pub driver_version: u32,
@@ -991,6 +1043,7 @@ pub struct PhysicalDeviceProperties {
     pub limits: PhysicalDeviceLimits,
     pub sparse_properties: PhysicalDeviceSparseProperties,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for PhysicalDeviceProperties {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("PhysicalDeviceProperties")
@@ -1000,7 +1053,7 @@ impl fmt::Debug for PhysicalDeviceProperties {
             .field("device_id", &self.device_id)
             .field("device_type", &self.device_type)
             .field("device_name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.device_name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.device_name.as_ptr())
             })
             .field("pipeline_cache_uuid", &self.pipeline_cache_uuid)
             .field("limits", &self.limits)
@@ -1009,8 +1062,9 @@ impl fmt::Debug for PhysicalDeviceProperties {
     }
 }
 impl ::std::default::Default for PhysicalDeviceProperties {
-    fn default() -> PhysicalDeviceProperties {
-        PhysicalDeviceProperties {
+    #[inline]
+    fn default() -> Self {
+        Self {
             api_version: u32::default(),
             driver_version: u32::default(),
             vendor_id: u32::default(),
@@ -1026,7 +1080,7 @@ impl ::std::default::Default for PhysicalDeviceProperties {
 impl PhysicalDeviceProperties {
     pub fn builder<'a>() -> PhysicalDevicePropertiesBuilder<'a> {
         PhysicalDevicePropertiesBuilder {
-            inner: PhysicalDeviceProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1048,38 +1102,47 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDevicePropertiesBuilder<'a> {
+    #[inline]
     pub fn api_version(mut self, api_version: u32) -> Self {
         self.inner.api_version = api_version;
         self
     }
+    #[inline]
     pub fn driver_version(mut self, driver_version: u32) -> Self {
         self.inner.driver_version = driver_version;
         self
     }
+    #[inline]
     pub fn vendor_id(mut self, vendor_id: u32) -> Self {
         self.inner.vendor_id = vendor_id;
         self
     }
+    #[inline]
     pub fn device_id(mut self, device_id: u32) -> Self {
         self.inner.device_id = device_id;
         self
     }
+    #[inline]
     pub fn device_type(mut self, device_type: PhysicalDeviceType) -> Self {
         self.inner.device_type = device_type;
         self
     }
+    #[inline]
     pub fn device_name(mut self, device_name: [c_char; MAX_PHYSICAL_DEVICE_NAME_SIZE]) -> Self {
         self.inner.device_name = device_name;
         self
     }
+    #[inline]
     pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
         self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
         self
     }
+    #[inline]
     pub fn limits(mut self, limits: PhysicalDeviceLimits) -> Self {
         self.inner.limits = limits;
         self
     }
+    #[inline]
     pub fn sparse_properties(mut self, sparse_properties: PhysicalDeviceSparseProperties) -> Self {
         self.inner.sparse_properties = sparse_properties;
         self
@@ -1093,24 +1156,26 @@ impl<'a> PhysicalDevicePropertiesBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExtensionProperties.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExtensionProperties.html>"]
 pub struct ExtensionProperties {
     pub extension_name: [c_char; MAX_EXTENSION_NAME_SIZE],
     pub spec_version: u32,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for ExtensionProperties {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("ExtensionProperties")
             .field("extension_name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.extension_name.as_ptr())
             })
             .field("spec_version", &self.spec_version)
             .finish()
     }
 }
 impl ::std::default::Default for ExtensionProperties {
-    fn default() -> ExtensionProperties {
-        ExtensionProperties {
+    #[inline]
+    fn default() -> Self {
+        Self {
             extension_name: unsafe { ::std::mem::zeroed() },
             spec_version: u32::default(),
         }
@@ -1119,7 +1184,7 @@ impl ::std::default::Default for ExtensionProperties {
 impl ExtensionProperties {
     pub fn builder<'a>() -> ExtensionPropertiesBuilder<'a> {
         ExtensionPropertiesBuilder {
-            inner: ExtensionProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1141,10 +1206,12 @@ impl<'a> ::std::ops::DerefMut for ExtensionPropertiesBuilder<'a> {
     }
 }
 impl<'a> ExtensionPropertiesBuilder<'a> {
+    #[inline]
     pub fn extension_name(mut self, extension_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
         self.inner.extension_name = extension_name;
         self
     }
+    #[inline]
     pub fn spec_version(mut self, spec_version: u32) -> Self {
         self.inner.spec_version = spec_version;
         self
@@ -1158,30 +1225,32 @@ impl<'a> ExtensionPropertiesBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkLayerProperties.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLayerProperties.html>"]
 pub struct LayerProperties {
     pub layer_name: [c_char; MAX_EXTENSION_NAME_SIZE],
     pub spec_version: u32,
     pub implementation_version: u32,
     pub description: [c_char; MAX_DESCRIPTION_SIZE],
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for LayerProperties {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("LayerProperties")
             .field("layer_name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.layer_name.as_ptr())
             })
             .field("spec_version", &self.spec_version)
             .field("implementation_version", &self.implementation_version)
             .field("description", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
             })
             .finish()
     }
 }
 impl ::std::default::Default for LayerProperties {
-    fn default() -> LayerProperties {
-        LayerProperties {
+    #[inline]
+    fn default() -> Self {
+        Self {
             layer_name: unsafe { ::std::mem::zeroed() },
             spec_version: u32::default(),
             implementation_version: u32::default(),
@@ -1192,7 +1261,7 @@ impl ::std::default::Default for LayerProperties {
 impl LayerProperties {
     pub fn builder<'a>() -> LayerPropertiesBuilder<'a> {
         LayerPropertiesBuilder {
-            inner: LayerProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1214,18 +1283,22 @@ impl<'a> ::std::ops::DerefMut for LayerPropertiesBuilder<'a> {
     }
 }
 impl<'a> LayerPropertiesBuilder<'a> {
+    #[inline]
     pub fn layer_name(mut self, layer_name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
         self.inner.layer_name = layer_name;
         self
     }
+    #[inline]
     pub fn spec_version(mut self, spec_version: u32) -> Self {
         self.inner.spec_version = spec_version;
         self
     }
+    #[inline]
     pub fn implementation_version(mut self, implementation_version: u32) -> Self {
         self.inner.implementation_version = implementation_version;
         self
     }
+    #[inline]
     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.description = description;
         self
@@ -1238,8 +1311,9 @@ impl<'a> LayerPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkApplicationInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkApplicationInfo.html>"]
 pub struct ApplicationInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -1250,9 +1324,10 @@ pub struct ApplicationInfo {
     pub api_version: u32,
 }
 impl ::std::default::Default for ApplicationInfo {
-    fn default() -> ApplicationInfo {
-        ApplicationInfo {
-            s_type: StructureType::APPLICATION_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_application_name: ::std::ptr::null(),
             application_version: u32::default(),
@@ -1262,10 +1337,13 @@ impl ::std::default::Default for ApplicationInfo {
         }
     }
 }
+unsafe impl TaggedStructure for ApplicationInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::APPLICATION_INFO;
+}
 impl ApplicationInfo {
     pub fn builder<'a>() -> ApplicationInfoBuilder<'a> {
         ApplicationInfoBuilder {
-            inner: ApplicationInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1287,22 +1365,27 @@ impl<'a> ::std::ops::DerefMut for ApplicationInfoBuilder<'a> {
     }
 }
 impl<'a> ApplicationInfoBuilder<'a> {
+    #[inline]
     pub fn application_name(mut self, application_name: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_application_name = application_name.as_ptr();
         self
     }
+    #[inline]
     pub fn application_version(mut self, application_version: u32) -> Self {
         self.inner.application_version = application_version;
         self
     }
+    #[inline]
     pub fn engine_name(mut self, engine_name: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_engine_name = engine_name.as_ptr();
         self
     }
+    #[inline]
     pub fn engine_version(mut self, engine_version: u32) -> Self {
         self.inner.engine_version = engine_version;
         self
     }
+    #[inline]
     pub fn api_version(mut self, api_version: u32) -> Self {
         self.inner.api_version = api_version;
         self
@@ -1316,7 +1399,7 @@ impl<'a> ApplicationInfoBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAllocationCallbacks.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAllocationCallbacks.html>"]
 pub struct AllocationCallbacks {
     pub p_user_data: *mut c_void,
     pub pfn_allocation: PFN_vkAllocationFunction,
@@ -1325,6 +1408,7 @@ pub struct AllocationCallbacks {
     pub pfn_internal_allocation: PFN_vkInternalAllocationNotification,
     pub pfn_internal_free: PFN_vkInternalFreeNotification,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for AllocationCallbacks {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("AllocationCallbacks")
@@ -1350,8 +1434,9 @@ impl fmt::Debug for AllocationCallbacks {
     }
 }
 impl ::std::default::Default for AllocationCallbacks {
-    fn default() -> AllocationCallbacks {
-        AllocationCallbacks {
+    #[inline]
+    fn default() -> Self {
+        Self {
             p_user_data: ::std::ptr::null_mut(),
             pfn_allocation: PFN_vkAllocationFunction::default(),
             pfn_reallocation: PFN_vkReallocationFunction::default(),
@@ -1364,7 +1449,7 @@ impl ::std::default::Default for AllocationCallbacks {
 impl AllocationCallbacks {
     pub fn builder<'a>() -> AllocationCallbacksBuilder<'a> {
         AllocationCallbacksBuilder {
-            inner: AllocationCallbacks::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1386,22 +1471,27 @@ impl<'a> ::std::ops::DerefMut for AllocationCallbacksBuilder<'a> {
     }
 }
 impl<'a> AllocationCallbacksBuilder<'a> {
+    #[inline]
     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
         self.inner.p_user_data = user_data;
         self
     }
+    #[inline]
     pub fn pfn_allocation(mut self, pfn_allocation: PFN_vkAllocationFunction) -> Self {
         self.inner.pfn_allocation = pfn_allocation;
         self
     }
+    #[inline]
     pub fn pfn_reallocation(mut self, pfn_reallocation: PFN_vkReallocationFunction) -> Self {
         self.inner.pfn_reallocation = pfn_reallocation;
         self
     }
+    #[inline]
     pub fn pfn_free(mut self, pfn_free: PFN_vkFreeFunction) -> Self {
         self.inner.pfn_free = pfn_free;
         self
     }
+    #[inline]
     pub fn pfn_internal_allocation(
         mut self,
         pfn_internal_allocation: PFN_vkInternalAllocationNotification,
@@ -1409,6 +1499,7 @@ impl<'a> AllocationCallbacksBuilder<'a> {
         self.inner.pfn_internal_allocation = pfn_internal_allocation;
         self
     }
+    #[inline]
     pub fn pfn_internal_free(mut self, pfn_internal_free: PFN_vkInternalFreeNotification) -> Self {
         self.inner.pfn_internal_free = pfn_internal_free;
         self
@@ -1421,8 +1512,9 @@ impl<'a> AllocationCallbacksBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueCreateInfo.html>"]
 pub struct DeviceQueueCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -1432,9 +1524,10 @@ pub struct DeviceQueueCreateInfo {
     pub p_queue_priorities: *const f32,
 }
 impl ::std::default::Default for DeviceQueueCreateInfo {
-    fn default() -> DeviceQueueCreateInfo {
-        DeviceQueueCreateInfo {
-            s_type: StructureType::DEVICE_QUEUE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DeviceQueueCreateFlags::default(),
             queue_family_index: u32::default(),
@@ -1443,10 +1536,13 @@ impl ::std::default::Default for DeviceQueueCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for DeviceQueueCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_QUEUE_CREATE_INFO;
+}
 impl DeviceQueueCreateInfo {
     pub fn builder<'a>() -> DeviceQueueCreateInfoBuilder<'a> {
         DeviceQueueCreateInfoBuilder {
-            inner: DeviceQueueCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1469,14 +1565,17 @@ impl<'a> ::std::ops::DerefMut for DeviceQueueCreateInfoBuilder<'a> {
     }
 }
 impl<'a> DeviceQueueCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
         self.inner.queue_family_index = queue_family_index;
         self
     }
+    #[inline]
     pub fn queue_priorities(mut self, queue_priorities: &'a [f32]) -> Self {
         self.inner.queue_count = queue_priorities.len() as _;
         self.inner.p_queue_priorities = queue_priorities.as_ptr();
@@ -1489,10 +1588,10 @@ impl<'a> DeviceQueueCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsDeviceQueueCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -1504,24 +1603,29 @@ impl<'a> DeviceQueueCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceCreateInfo.html>"]
 pub struct DeviceCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: DeviceCreateFlags,
     pub queue_create_info_count: u32,
     pub p_queue_create_infos: *const DeviceQueueCreateInfo,
+    #[deprecated = "functionality described by this member no longer operates"]
     pub enabled_layer_count: u32,
+    #[deprecated = "functionality described by this member no longer operates"]
     pub pp_enabled_layer_names: *const *const c_char,
     pub enabled_extension_count: u32,
     pub pp_enabled_extension_names: *const *const c_char,
     pub p_enabled_features: *const PhysicalDeviceFeatures,
 }
 impl ::std::default::Default for DeviceCreateInfo {
-    fn default() -> DeviceCreateInfo {
-        DeviceCreateInfo {
-            s_type: StructureType::DEVICE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        #[allow(deprecated)]
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DeviceCreateFlags::default(),
             queue_create_info_count: u32::default(),
@@ -1534,10 +1638,13 @@ impl ::std::default::Default for DeviceCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for DeviceCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_CREATE_INFO;
+}
 impl DeviceCreateInfo {
     pub fn builder<'a>() -> DeviceCreateInfoBuilder<'a> {
         DeviceCreateInfoBuilder {
-            inner: DeviceCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1560,25 +1667,32 @@ impl<'a> ::std::ops::DerefMut for DeviceCreateInfoBuilder<'a> {
     }
 }
 impl<'a> DeviceCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DeviceCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn queue_create_infos(mut self, queue_create_infos: &'a [DeviceQueueCreateInfo]) -> Self {
         self.inner.queue_create_info_count = queue_create_infos.len() as _;
         self.inner.p_queue_create_infos = queue_create_infos.as_ptr();
         self
     }
+    #[inline]
+    #[deprecated = "functionality described by this member no longer operates"]
+    #[allow(deprecated)]
     pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self {
         self.inner.enabled_layer_count = enabled_layer_names.len() as _;
         self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
         self
     }
+    #[inline]
     pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self {
         self.inner.enabled_extension_count = enabled_extension_names.len() as _;
         self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
         self
     }
+    #[inline]
     pub fn enabled_features(mut self, enabled_features: &'a PhysicalDeviceFeatures) -> Self {
         self.inner.p_enabled_features = enabled_features;
         self
@@ -1590,10 +1704,10 @@ impl<'a> DeviceCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsDeviceCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -1605,8 +1719,9 @@ impl<'a> DeviceCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInstanceCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInstanceCreateInfo.html>"]
 pub struct InstanceCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -1618,9 +1733,10 @@ pub struct InstanceCreateInfo {
     pub pp_enabled_extension_names: *const *const c_char,
 }
 impl ::std::default::Default for InstanceCreateInfo {
-    fn default() -> InstanceCreateInfo {
-        InstanceCreateInfo {
-            s_type: StructureType::INSTANCE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: InstanceCreateFlags::default(),
             p_application_info: ::std::ptr::null(),
@@ -1631,10 +1747,13 @@ impl ::std::default::Default for InstanceCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for InstanceCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::INSTANCE_CREATE_INFO;
+}
 impl InstanceCreateInfo {
     pub fn builder<'a>() -> InstanceCreateInfoBuilder<'a> {
         InstanceCreateInfoBuilder {
-            inner: InstanceCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1657,19 +1776,23 @@ impl<'a> ::std::ops::DerefMut for InstanceCreateInfoBuilder<'a> {
     }
 }
 impl<'a> InstanceCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: InstanceCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn application_info(mut self, application_info: &'a ApplicationInfo) -> Self {
         self.inner.p_application_info = application_info;
         self
     }
+    #[inline]
     pub fn enabled_layer_names(mut self, enabled_layer_names: &'a [*const c_char]) -> Self {
         self.inner.enabled_layer_count = enabled_layer_names.len() as _;
         self.inner.pp_enabled_layer_names = enabled_layer_names.as_ptr();
         self
     }
+    #[inline]
     pub fn enabled_extension_names(mut self, enabled_extension_names: &'a [*const c_char]) -> Self {
         self.inner.enabled_extension_count = enabled_extension_names.len() as _;
         self.inner.pp_enabled_extension_names = enabled_extension_names.as_ptr();
@@ -1682,10 +1805,10 @@ impl<'a> InstanceCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsInstanceCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -1697,8 +1820,9 @@ impl<'a> InstanceCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties.html>"]
 pub struct QueueFamilyProperties {
     pub queue_flags: QueueFlags,
     pub queue_count: u32,
@@ -1708,7 +1832,7 @@ pub struct QueueFamilyProperties {
 impl QueueFamilyProperties {
     pub fn builder<'a>() -> QueueFamilyPropertiesBuilder<'a> {
         QueueFamilyPropertiesBuilder {
-            inner: QueueFamilyProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1730,18 +1854,22 @@ impl<'a> ::std::ops::DerefMut for QueueFamilyPropertiesBuilder<'a> {
     }
 }
 impl<'a> QueueFamilyPropertiesBuilder<'a> {
+    #[inline]
     pub fn queue_flags(mut self, queue_flags: QueueFlags) -> Self {
         self.inner.queue_flags = queue_flags;
         self
     }
+    #[inline]
     pub fn queue_count(mut self, queue_count: u32) -> Self {
         self.inner.queue_count = queue_count;
         self
     }
+    #[inline]
     pub fn timestamp_valid_bits(mut self, timestamp_valid_bits: u32) -> Self {
         self.inner.timestamp_valid_bits = timestamp_valid_bits;
         self
     }
+    #[inline]
     pub fn min_image_transfer_granularity(
         mut self,
         min_image_transfer_granularity: Extent3D,
@@ -1757,8 +1885,9 @@ impl<'a> QueueFamilyPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties.html>"]
 pub struct PhysicalDeviceMemoryProperties {
     pub memory_type_count: u32,
     pub memory_types: [MemoryType; MAX_MEMORY_TYPES],
@@ -1766,8 +1895,9 @@ pub struct PhysicalDeviceMemoryProperties {
     pub memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS],
 }
 impl ::std::default::Default for PhysicalDeviceMemoryProperties {
-    fn default() -> PhysicalDeviceMemoryProperties {
-        PhysicalDeviceMemoryProperties {
+    #[inline]
+    fn default() -> Self {
+        Self {
             memory_type_count: u32::default(),
             memory_types: unsafe { ::std::mem::zeroed() },
             memory_heap_count: u32::default(),
@@ -1778,7 +1908,7 @@ impl ::std::default::Default for PhysicalDeviceMemoryProperties {
 impl PhysicalDeviceMemoryProperties {
     pub fn builder<'a>() -> PhysicalDeviceMemoryPropertiesBuilder<'a> {
         PhysicalDeviceMemoryPropertiesBuilder {
-            inner: PhysicalDeviceMemoryProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1800,18 +1930,22 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> {
+    #[inline]
     pub fn memory_type_count(mut self, memory_type_count: u32) -> Self {
         self.inner.memory_type_count = memory_type_count;
         self
     }
+    #[inline]
     pub fn memory_types(mut self, memory_types: [MemoryType; MAX_MEMORY_TYPES]) -> Self {
         self.inner.memory_types = memory_types;
         self
     }
+    #[inline]
     pub fn memory_heap_count(mut self, memory_heap_count: u32) -> Self {
         self.inner.memory_heap_count = memory_heap_count;
         self
     }
+    #[inline]
     pub fn memory_heaps(mut self, memory_heaps: [MemoryHeap; MAX_MEMORY_HEAPS]) -> Self {
         self.inner.memory_heaps = memory_heaps;
         self
@@ -1824,8 +1958,9 @@ impl<'a> PhysicalDeviceMemoryPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateInfo.html>"]
 pub struct MemoryAllocateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -1833,19 +1968,23 @@ pub struct MemoryAllocateInfo {
     pub memory_type_index: u32,
 }
 impl ::std::default::Default for MemoryAllocateInfo {
-    fn default() -> MemoryAllocateInfo {
-        MemoryAllocateInfo {
-            s_type: StructureType::MEMORY_ALLOCATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             allocation_size: DeviceSize::default(),
             memory_type_index: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryAllocateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ALLOCATE_INFO;
+}
 impl MemoryAllocateInfo {
     pub fn builder<'a>() -> MemoryAllocateInfoBuilder<'a> {
         MemoryAllocateInfoBuilder {
-            inner: MemoryAllocateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1868,10 +2007,12 @@ impl<'a> ::std::ops::DerefMut for MemoryAllocateInfoBuilder<'a> {
     }
 }
 impl<'a> MemoryAllocateInfoBuilder<'a> {
+    #[inline]
     pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self {
         self.inner.allocation_size = allocation_size;
         self
     }
+    #[inline]
     pub fn memory_type_index(mut self, memory_type_index: u32) -> Self {
         self.inner.memory_type_index = memory_type_index;
         self
@@ -1883,10 +2024,10 @@ impl<'a> MemoryAllocateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsMemoryAllocateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -1898,8 +2039,9 @@ impl<'a> MemoryAllocateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryRequirements.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements.html>"]
 pub struct MemoryRequirements {
     pub size: DeviceSize,
     pub alignment: DeviceSize,
@@ -1908,7 +2050,7 @@ pub struct MemoryRequirements {
 impl MemoryRequirements {
     pub fn builder<'a>() -> MemoryRequirementsBuilder<'a> {
         MemoryRequirementsBuilder {
-            inner: MemoryRequirements::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1930,14 +2072,17 @@ impl<'a> ::std::ops::DerefMut for MemoryRequirementsBuilder<'a> {
     }
 }
 impl<'a> MemoryRequirementsBuilder<'a> {
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
     }
+    #[inline]
     pub fn alignment(mut self, alignment: DeviceSize) -> Self {
         self.inner.alignment = alignment;
         self
     }
+    #[inline]
     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
         self.inner.memory_type_bits = memory_type_bits;
         self
@@ -1950,8 +2095,9 @@ impl<'a> MemoryRequirementsBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties.html>"]
 pub struct SparseImageFormatProperties {
     pub aspect_mask: ImageAspectFlags,
     pub image_granularity: Extent3D,
@@ -1960,7 +2106,7 @@ pub struct SparseImageFormatProperties {
 impl SparseImageFormatProperties {
     pub fn builder<'a>() -> SparseImageFormatPropertiesBuilder<'a> {
         SparseImageFormatPropertiesBuilder {
-            inner: SparseImageFormatProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -1982,14 +2128,17 @@ impl<'a> ::std::ops::DerefMut for SparseImageFormatPropertiesBuilder<'a> {
     }
 }
 impl<'a> SparseImageFormatPropertiesBuilder<'a> {
+    #[inline]
     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
         self.inner.aspect_mask = aspect_mask;
         self
     }
+    #[inline]
     pub fn image_granularity(mut self, image_granularity: Extent3D) -> Self {
         self.inner.image_granularity = image_granularity;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: SparseImageFormatFlags) -> Self {
         self.inner.flags = flags;
         self
@@ -2002,8 +2151,9 @@ impl<'a> SparseImageFormatPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryRequirements.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements.html>"]
 pub struct SparseImageMemoryRequirements {
     pub format_properties: SparseImageFormatProperties,
     pub image_mip_tail_first_lod: u32,
@@ -2014,7 +2164,7 @@ pub struct SparseImageMemoryRequirements {
 impl SparseImageMemoryRequirements {
     pub fn builder<'a>() -> SparseImageMemoryRequirementsBuilder<'a> {
         SparseImageMemoryRequirementsBuilder {
-            inner: SparseImageMemoryRequirements::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2036,22 +2186,27 @@ impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirementsBuilder<'a> {
     }
 }
 impl<'a> SparseImageMemoryRequirementsBuilder<'a> {
+    #[inline]
     pub fn format_properties(mut self, format_properties: SparseImageFormatProperties) -> Self {
         self.inner.format_properties = format_properties;
         self
     }
+    #[inline]
     pub fn image_mip_tail_first_lod(mut self, image_mip_tail_first_lod: u32) -> Self {
         self.inner.image_mip_tail_first_lod = image_mip_tail_first_lod;
         self
     }
+    #[inline]
     pub fn image_mip_tail_size(mut self, image_mip_tail_size: DeviceSize) -> Self {
         self.inner.image_mip_tail_size = image_mip_tail_size;
         self
     }
+    #[inline]
     pub fn image_mip_tail_offset(mut self, image_mip_tail_offset: DeviceSize) -> Self {
         self.inner.image_mip_tail_offset = image_mip_tail_offset;
         self
     }
+    #[inline]
     pub fn image_mip_tail_stride(mut self, image_mip_tail_stride: DeviceSize) -> Self {
         self.inner.image_mip_tail_stride = image_mip_tail_stride;
         self
@@ -2064,8 +2219,9 @@ impl<'a> SparseImageMemoryRequirementsBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryType.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryType.html>"]
 pub struct MemoryType {
     pub property_flags: MemoryPropertyFlags,
     pub heap_index: u32,
@@ -2073,7 +2229,7 @@ pub struct MemoryType {
 impl MemoryType {
     pub fn builder<'a>() -> MemoryTypeBuilder<'a> {
         MemoryTypeBuilder {
-            inner: MemoryType::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2095,10 +2251,12 @@ impl<'a> ::std::ops::DerefMut for MemoryTypeBuilder<'a> {
     }
 }
 impl<'a> MemoryTypeBuilder<'a> {
+    #[inline]
     pub fn property_flags(mut self, property_flags: MemoryPropertyFlags) -> Self {
         self.inner.property_flags = property_flags;
         self
     }
+    #[inline]
     pub fn heap_index(mut self, heap_index: u32) -> Self {
         self.inner.heap_index = heap_index;
         self
@@ -2111,8 +2269,9 @@ impl<'a> MemoryTypeBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHeap.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHeap.html>"]
 pub struct MemoryHeap {
     pub size: DeviceSize,
     pub flags: MemoryHeapFlags,
@@ -2120,7 +2279,7 @@ pub struct MemoryHeap {
 impl MemoryHeap {
     pub fn builder<'a>() -> MemoryHeapBuilder<'a> {
         MemoryHeapBuilder {
-            inner: MemoryHeap::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2142,10 +2301,12 @@ impl<'a> ::std::ops::DerefMut for MemoryHeapBuilder<'a> {
     }
 }
 impl<'a> MemoryHeapBuilder<'a> {
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: MemoryHeapFlags) -> Self {
         self.inner.flags = flags;
         self
@@ -2158,8 +2319,9 @@ impl<'a> MemoryHeapBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMappedMemoryRange.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMappedMemoryRange.html>"]
 pub struct MappedMemoryRange {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -2168,9 +2330,10 @@ pub struct MappedMemoryRange {
     pub size: DeviceSize,
 }
 impl ::std::default::Default for MappedMemoryRange {
-    fn default() -> MappedMemoryRange {
-        MappedMemoryRange {
-            s_type: StructureType::MAPPED_MEMORY_RANGE,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             memory: DeviceMemory::default(),
             offset: DeviceSize::default(),
@@ -2178,10 +2341,13 @@ impl ::std::default::Default for MappedMemoryRange {
         }
     }
 }
+unsafe impl TaggedStructure for MappedMemoryRange {
+    const STRUCTURE_TYPE: StructureType = StructureType::MAPPED_MEMORY_RANGE;
+}
 impl MappedMemoryRange {
     pub fn builder<'a>() -> MappedMemoryRangeBuilder<'a> {
         MappedMemoryRangeBuilder {
-            inner: MappedMemoryRange::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2203,14 +2369,17 @@ impl<'a> ::std::ops::DerefMut for MappedMemoryRangeBuilder<'a> {
     }
 }
 impl<'a> MappedMemoryRangeBuilder<'a> {
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
@@ -2223,8 +2392,9 @@ impl<'a> MappedMemoryRangeBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties.html>"]
 pub struct FormatProperties {
     pub linear_tiling_features: FormatFeatureFlags,
     pub optimal_tiling_features: FormatFeatureFlags,
@@ -2233,7 +2403,7 @@ pub struct FormatProperties {
 impl FormatProperties {
     pub fn builder<'a>() -> FormatPropertiesBuilder<'a> {
         FormatPropertiesBuilder {
-            inner: FormatProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2255,14 +2425,17 @@ impl<'a> ::std::ops::DerefMut for FormatPropertiesBuilder<'a> {
     }
 }
 impl<'a> FormatPropertiesBuilder<'a> {
+    #[inline]
     pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags) -> Self {
         self.inner.linear_tiling_features = linear_tiling_features;
         self
     }
+    #[inline]
     pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags) -> Self {
         self.inner.optimal_tiling_features = optimal_tiling_features;
         self
     }
+    #[inline]
     pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags) -> Self {
         self.inner.buffer_features = buffer_features;
         self
@@ -2275,8 +2448,9 @@ impl<'a> FormatPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties.html>"]
 pub struct ImageFormatProperties {
     pub max_extent: Extent3D,
     pub max_mip_levels: u32,
@@ -2287,7 +2461,7 @@ pub struct ImageFormatProperties {
 impl ImageFormatProperties {
     pub fn builder<'a>() -> ImageFormatPropertiesBuilder<'a> {
         ImageFormatPropertiesBuilder {
-            inner: ImageFormatProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2309,22 +2483,27 @@ impl<'a> ::std::ops::DerefMut for ImageFormatPropertiesBuilder<'a> {
     }
 }
 impl<'a> ImageFormatPropertiesBuilder<'a> {
+    #[inline]
     pub fn max_extent(mut self, max_extent: Extent3D) -> Self {
         self.inner.max_extent = max_extent;
         self
     }
+    #[inline]
     pub fn max_mip_levels(mut self, max_mip_levels: u32) -> Self {
         self.inner.max_mip_levels = max_mip_levels;
         self
     }
+    #[inline]
     pub fn max_array_layers(mut self, max_array_layers: u32) -> Self {
         self.inner.max_array_layers = max_array_layers;
         self
     }
+    #[inline]
     pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self {
         self.inner.sample_counts = sample_counts;
         self
     }
+    #[inline]
     pub fn max_resource_size(mut self, max_resource_size: DeviceSize) -> Self {
         self.inner.max_resource_size = max_resource_size;
         self
@@ -2337,8 +2516,9 @@ impl<'a> ImageFormatPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorBufferInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferInfo.html>"]
 pub struct DescriptorBufferInfo {
     pub buffer: Buffer,
     pub offset: DeviceSize,
@@ -2347,7 +2527,7 @@ pub struct DescriptorBufferInfo {
 impl DescriptorBufferInfo {
     pub fn builder<'a>() -> DescriptorBufferInfoBuilder<'a> {
         DescriptorBufferInfoBuilder {
-            inner: DescriptorBufferInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2369,14 +2549,17 @@ impl<'a> ::std::ops::DerefMut for DescriptorBufferInfoBuilder<'a> {
     }
 }
 impl<'a> DescriptorBufferInfoBuilder<'a> {
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn range(mut self, range: DeviceSize) -> Self {
         self.inner.range = range;
         self
@@ -2389,8 +2572,9 @@ impl<'a> DescriptorBufferInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorImageInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorImageInfo.html>"]
 pub struct DescriptorImageInfo {
     pub sampler: Sampler,
     pub image_view: ImageView,
@@ -2399,7 +2583,7 @@ pub struct DescriptorImageInfo {
 impl DescriptorImageInfo {
     pub fn builder<'a>() -> DescriptorImageInfoBuilder<'a> {
         DescriptorImageInfoBuilder {
-            inner: DescriptorImageInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2421,14 +2605,17 @@ impl<'a> ::std::ops::DerefMut for DescriptorImageInfoBuilder<'a> {
     }
 }
 impl<'a> DescriptorImageInfoBuilder<'a> {
+    #[inline]
     pub fn sampler(mut self, sampler: Sampler) -> Self {
         self.inner.sampler = sampler;
         self
     }
+    #[inline]
     pub fn image_view(mut self, image_view: ImageView) -> Self {
         self.inner.image_view = image_view;
         self
     }
+    #[inline]
     pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
         self.inner.image_layout = image_layout;
         self
@@ -2441,8 +2628,9 @@ impl<'a> DescriptorImageInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSet.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSet.html>"]
 pub struct WriteDescriptorSet {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -2456,9 +2644,10 @@ pub struct WriteDescriptorSet {
     pub p_texel_buffer_view: *const BufferView,
 }
 impl ::std::default::Default for WriteDescriptorSet {
-    fn default() -> WriteDescriptorSet {
-        WriteDescriptorSet {
-            s_type: StructureType::WRITE_DESCRIPTOR_SET,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             dst_set: DescriptorSet::default(),
             dst_binding: u32::default(),
@@ -2471,10 +2660,13 @@ impl ::std::default::Default for WriteDescriptorSet {
         }
     }
 }
+unsafe impl TaggedStructure for WriteDescriptorSet {
+    const STRUCTURE_TYPE: StructureType = StructureType::WRITE_DESCRIPTOR_SET;
+}
 impl WriteDescriptorSet {
     pub fn builder<'a>() -> WriteDescriptorSetBuilder<'a> {
         WriteDescriptorSetBuilder {
-            inner: WriteDescriptorSet::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2497,32 +2689,39 @@ impl<'a> ::std::ops::DerefMut for WriteDescriptorSetBuilder<'a> {
     }
 }
 impl<'a> WriteDescriptorSetBuilder<'a> {
+    #[inline]
     pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self {
         self.inner.dst_set = dst_set;
         self
     }
+    #[inline]
     pub fn dst_binding(mut self, dst_binding: u32) -> Self {
         self.inner.dst_binding = dst_binding;
         self
     }
+    #[inline]
     pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
         self.inner.dst_array_element = dst_array_element;
         self
     }
+    #[inline]
     pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
         self.inner.descriptor_type = descriptor_type;
         self
     }
+    #[inline]
     pub fn image_info(mut self, image_info: &'a [DescriptorImageInfo]) -> Self {
         self.inner.descriptor_count = image_info.len() as _;
         self.inner.p_image_info = image_info.as_ptr();
         self
     }
+    #[inline]
     pub fn buffer_info(mut self, buffer_info: &'a [DescriptorBufferInfo]) -> Self {
         self.inner.descriptor_count = buffer_info.len() as _;
         self.inner.p_buffer_info = buffer_info.as_ptr();
         self
     }
+    #[inline]
     pub fn texel_buffer_view(mut self, texel_buffer_view: &'a [BufferView]) -> Self {
         self.inner.descriptor_count = texel_buffer_view.len() as _;
         self.inner.p_texel_buffer_view = texel_buffer_view.as_ptr();
@@ -2535,10 +2734,10 @@ impl<'a> WriteDescriptorSetBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsWriteDescriptorSet>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -2550,8 +2749,9 @@ impl<'a> WriteDescriptorSetBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyDescriptorSet.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyDescriptorSet.html>"]
 pub struct CopyDescriptorSet {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -2564,9 +2764,10 @@ pub struct CopyDescriptorSet {
     pub descriptor_count: u32,
 }
 impl ::std::default::Default for CopyDescriptorSet {
-    fn default() -> CopyDescriptorSet {
-        CopyDescriptorSet {
-            s_type: StructureType::COPY_DESCRIPTOR_SET,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_set: DescriptorSet::default(),
             src_binding: u32::default(),
@@ -2578,10 +2779,13 @@ impl ::std::default::Default for CopyDescriptorSet {
         }
     }
 }
+unsafe impl TaggedStructure for CopyDescriptorSet {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_DESCRIPTOR_SET;
+}
 impl CopyDescriptorSet {
     pub fn builder<'a>() -> CopyDescriptorSetBuilder<'a> {
         CopyDescriptorSetBuilder {
-            inner: CopyDescriptorSet::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2603,30 +2807,37 @@ impl<'a> ::std::ops::DerefMut for CopyDescriptorSetBuilder<'a> {
     }
 }
 impl<'a> CopyDescriptorSetBuilder<'a> {
+    #[inline]
     pub fn src_set(mut self, src_set: DescriptorSet) -> Self {
         self.inner.src_set = src_set;
         self
     }
+    #[inline]
     pub fn src_binding(mut self, src_binding: u32) -> Self {
         self.inner.src_binding = src_binding;
         self
     }
+    #[inline]
     pub fn src_array_element(mut self, src_array_element: u32) -> Self {
         self.inner.src_array_element = src_array_element;
         self
     }
+    #[inline]
     pub fn dst_set(mut self, dst_set: DescriptorSet) -> Self {
         self.inner.dst_set = dst_set;
         self
     }
+    #[inline]
     pub fn dst_binding(mut self, dst_binding: u32) -> Self {
         self.inner.dst_binding = dst_binding;
         self
     }
+    #[inline]
     pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
         self.inner.dst_array_element = dst_array_element;
         self
     }
+    #[inline]
     pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
         self.inner.descriptor_count = descriptor_count;
         self
@@ -2639,8 +2850,9 @@ impl<'a> CopyDescriptorSetBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCreateInfo.html>"]
 pub struct BufferCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -2652,9 +2864,10 @@ pub struct BufferCreateInfo {
     pub p_queue_family_indices: *const u32,
 }
 impl ::std::default::Default for BufferCreateInfo {
-    fn default() -> BufferCreateInfo {
-        BufferCreateInfo {
-            s_type: StructureType::BUFFER_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: BufferCreateFlags::default(),
             size: DeviceSize::default(),
@@ -2665,10 +2878,13 @@ impl ::std::default::Default for BufferCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for BufferCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CREATE_INFO;
+}
 impl BufferCreateInfo {
     pub fn builder<'a>() -> BufferCreateInfoBuilder<'a> {
         BufferCreateInfoBuilder {
-            inner: BufferCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2691,22 +2907,27 @@ impl<'a> ::std::ops::DerefMut for BufferCreateInfoBuilder<'a> {
     }
 }
 impl<'a> BufferCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: BufferCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
     }
+    #[inline]
     pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
         self.inner.usage = usage;
         self
     }
+    #[inline]
     pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
         self.inner.sharing_mode = sharing_mode;
         self
     }
+    #[inline]
     pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
         self.inner.queue_family_index_count = queue_family_indices.len() as _;
         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
@@ -2719,10 +2940,10 @@ impl<'a> BufferCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsBufferCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -2734,8 +2955,9 @@ impl<'a> BufferCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferViewCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferViewCreateInfo.html>"]
 pub struct BufferViewCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -2746,9 +2968,10 @@ pub struct BufferViewCreateInfo {
     pub range: DeviceSize,
 }
 impl ::std::default::Default for BufferViewCreateInfo {
-    fn default() -> BufferViewCreateInfo {
-        BufferViewCreateInfo {
-            s_type: StructureType::BUFFER_VIEW_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: BufferViewCreateFlags::default(),
             buffer: Buffer::default(),
@@ -2758,10 +2981,13 @@ impl ::std::default::Default for BufferViewCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for BufferViewCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_VIEW_CREATE_INFO;
+}
 impl BufferViewCreateInfo {
     pub fn builder<'a>() -> BufferViewCreateInfoBuilder<'a> {
         BufferViewCreateInfoBuilder {
-            inner: BufferViewCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2771,6 +2997,7 @@ pub struct BufferViewCreateInfoBuilder<'a> {
     inner: BufferViewCreateInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+pub unsafe trait ExtendsBufferViewCreateInfo {}
 impl<'a> ::std::ops::Deref for BufferViewCreateInfoBuilder<'a> {
     type Target = BufferViewCreateInfo;
     fn deref(&self) -> &Self::Target {
@@ -2783,26 +3010,45 @@ impl<'a> ::std::ops::DerefMut for BufferViewCreateInfoBuilder<'a> {
     }
 }
 impl<'a> BufferViewCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: BufferViewCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
     }
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn range(mut self, range: DeviceSize) -> Self {
         self.inner.range = range;
         self
     }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsBufferViewCreateInfo>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
@@ -2811,8 +3057,9 @@ impl<'a> BufferViewCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSubresource.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource.html>"]
 pub struct ImageSubresource {
     pub aspect_mask: ImageAspectFlags,
     pub mip_level: u32,
@@ -2821,7 +3068,7 @@ pub struct ImageSubresource {
 impl ImageSubresource {
     pub fn builder<'a>() -> ImageSubresourceBuilder<'a> {
         ImageSubresourceBuilder {
-            inner: ImageSubresource::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2843,14 +3090,17 @@ impl<'a> ::std::ops::DerefMut for ImageSubresourceBuilder<'a> {
     }
 }
 impl<'a> ImageSubresourceBuilder<'a> {
+    #[inline]
     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
         self.inner.aspect_mask = aspect_mask;
         self
     }
+    #[inline]
     pub fn mip_level(mut self, mip_level: u32) -> Self {
         self.inner.mip_level = mip_level;
         self
     }
+    #[inline]
     pub fn array_layer(mut self, array_layer: u32) -> Self {
         self.inner.array_layer = array_layer;
         self
@@ -2863,8 +3113,9 @@ impl<'a> ImageSubresourceBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSubresourceLayers.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceLayers.html>"]
 pub struct ImageSubresourceLayers {
     pub aspect_mask: ImageAspectFlags,
     pub mip_level: u32,
@@ -2874,7 +3125,7 @@ pub struct ImageSubresourceLayers {
 impl ImageSubresourceLayers {
     pub fn builder<'a>() -> ImageSubresourceLayersBuilder<'a> {
         ImageSubresourceLayersBuilder {
-            inner: ImageSubresourceLayers::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2896,18 +3147,22 @@ impl<'a> ::std::ops::DerefMut for ImageSubresourceLayersBuilder<'a> {
     }
 }
 impl<'a> ImageSubresourceLayersBuilder<'a> {
+    #[inline]
     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
         self.inner.aspect_mask = aspect_mask;
         self
     }
+    #[inline]
     pub fn mip_level(mut self, mip_level: u32) -> Self {
         self.inner.mip_level = mip_level;
         self
     }
+    #[inline]
     pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
         self.inner.base_array_layer = base_array_layer;
         self
     }
+    #[inline]
     pub fn layer_count(mut self, layer_count: u32) -> Self {
         self.inner.layer_count = layer_count;
         self
@@ -2920,8 +3175,9 @@ impl<'a> ImageSubresourceLayersBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSubresourceRange.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresourceRange.html>"]
 pub struct ImageSubresourceRange {
     pub aspect_mask: ImageAspectFlags,
     pub base_mip_level: u32,
@@ -2932,7 +3188,7 @@ pub struct ImageSubresourceRange {
 impl ImageSubresourceRange {
     pub fn builder<'a>() -> ImageSubresourceRangeBuilder<'a> {
         ImageSubresourceRangeBuilder {
-            inner: ImageSubresourceRange::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -2954,22 +3210,27 @@ impl<'a> ::std::ops::DerefMut for ImageSubresourceRangeBuilder<'a> {
     }
 }
 impl<'a> ImageSubresourceRangeBuilder<'a> {
+    #[inline]
     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
         self.inner.aspect_mask = aspect_mask;
         self
     }
+    #[inline]
     pub fn base_mip_level(mut self, base_mip_level: u32) -> Self {
         self.inner.base_mip_level = base_mip_level;
         self
     }
+    #[inline]
     pub fn level_count(mut self, level_count: u32) -> Self {
         self.inner.level_count = level_count;
         self
     }
+    #[inline]
     pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
         self.inner.base_array_layer = base_array_layer;
         self
     }
+    #[inline]
     pub fn layer_count(mut self, layer_count: u32) -> Self {
         self.inner.layer_count = layer_count;
         self
@@ -2982,8 +3243,9 @@ impl<'a> ImageSubresourceRangeBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryBarrier.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier.html>"]
 pub struct MemoryBarrier {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -2991,19 +3253,23 @@ pub struct MemoryBarrier {
     pub dst_access_mask: AccessFlags,
 }
 impl ::std::default::Default for MemoryBarrier {
-    fn default() -> MemoryBarrier {
-        MemoryBarrier {
-            s_type: StructureType::MEMORY_BARRIER,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_access_mask: AccessFlags::default(),
             dst_access_mask: AccessFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryBarrier {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_BARRIER;
+}
 impl MemoryBarrier {
     pub fn builder<'a>() -> MemoryBarrierBuilder<'a> {
         MemoryBarrierBuilder {
-            inner: MemoryBarrier::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3025,10 +3291,12 @@ impl<'a> ::std::ops::DerefMut for MemoryBarrierBuilder<'a> {
     }
 }
 impl<'a> MemoryBarrierBuilder<'a> {
+    #[inline]
     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
         self.inner.src_access_mask = src_access_mask;
         self
     }
+    #[inline]
     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
         self.inner.dst_access_mask = dst_access_mask;
         self
@@ -3041,8 +3309,9 @@ impl<'a> MemoryBarrierBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferMemoryBarrier.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier.html>"]
 pub struct BufferMemoryBarrier {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -3055,9 +3324,10 @@ pub struct BufferMemoryBarrier {
     pub size: DeviceSize,
 }
 impl ::std::default::Default for BufferMemoryBarrier {
-    fn default() -> BufferMemoryBarrier {
-        BufferMemoryBarrier {
-            s_type: StructureType::BUFFER_MEMORY_BARRIER,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_access_mask: AccessFlags::default(),
             dst_access_mask: AccessFlags::default(),
@@ -3069,10 +3339,13 @@ impl ::std::default::Default for BufferMemoryBarrier {
         }
     }
 }
+unsafe impl TaggedStructure for BufferMemoryBarrier {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER;
+}
 impl BufferMemoryBarrier {
     pub fn builder<'a>() -> BufferMemoryBarrierBuilder<'a> {
         BufferMemoryBarrierBuilder {
-            inner: BufferMemoryBarrier::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3094,30 +3367,37 @@ impl<'a> ::std::ops::DerefMut for BufferMemoryBarrierBuilder<'a> {
     }
 }
 impl<'a> BufferMemoryBarrierBuilder<'a> {
+    #[inline]
     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
         self.inner.src_access_mask = src_access_mask;
         self
     }
+    #[inline]
     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
         self.inner.dst_access_mask = dst_access_mask;
         self
     }
+    #[inline]
     pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
         self.inner.src_queue_family_index = src_queue_family_index;
         self
     }
+    #[inline]
     pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
         self.inner.dst_queue_family_index = dst_queue_family_index;
         self
     }
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
@@ -3130,8 +3410,9 @@ impl<'a> BufferMemoryBarrierBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageMemoryBarrier.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier.html>"]
 pub struct ImageMemoryBarrier {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -3145,9 +3426,10 @@ pub struct ImageMemoryBarrier {
     pub subresource_range: ImageSubresourceRange,
 }
 impl ::std::default::Default for ImageMemoryBarrier {
-    fn default() -> ImageMemoryBarrier {
-        ImageMemoryBarrier {
-            s_type: StructureType::IMAGE_MEMORY_BARRIER,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_access_mask: AccessFlags::default(),
             dst_access_mask: AccessFlags::default(),
@@ -3160,10 +3442,13 @@ impl ::std::default::Default for ImageMemoryBarrier {
         }
     }
 }
+unsafe impl TaggedStructure for ImageMemoryBarrier {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_BARRIER;
+}
 impl ImageMemoryBarrier {
     pub fn builder<'a>() -> ImageMemoryBarrierBuilder<'a> {
         ImageMemoryBarrierBuilder {
-            inner: ImageMemoryBarrier::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3186,34 +3471,42 @@ impl<'a> ::std::ops::DerefMut for ImageMemoryBarrierBuilder<'a> {
     }
 }
 impl<'a> ImageMemoryBarrierBuilder<'a> {
+    #[inline]
     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
         self.inner.src_access_mask = src_access_mask;
         self
     }
+    #[inline]
     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
         self.inner.dst_access_mask = dst_access_mask;
         self
     }
+    #[inline]
     pub fn old_layout(mut self, old_layout: ImageLayout) -> Self {
         self.inner.old_layout = old_layout;
         self
     }
+    #[inline]
     pub fn new_layout(mut self, new_layout: ImageLayout) -> Self {
         self.inner.new_layout = new_layout;
         self
     }
+    #[inline]
     pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
         self.inner.src_queue_family_index = src_queue_family_index;
         self
     }
+    #[inline]
     pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
         self.inner.dst_queue_family_index = dst_queue_family_index;
         self
     }
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
     }
+    #[inline]
     pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
         self.inner.subresource_range = subresource_range;
         self
@@ -3225,10 +3518,10 @@ impl<'a> ImageMemoryBarrierBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsImageMemoryBarrier>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -3240,8 +3533,9 @@ impl<'a> ImageMemoryBarrierBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCreateInfo.html>"]
 pub struct ImageCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -3260,9 +3554,10 @@ pub struct ImageCreateInfo {
     pub initial_layout: ImageLayout,
 }
 impl ::std::default::Default for ImageCreateInfo {
-    fn default() -> ImageCreateInfo {
-        ImageCreateInfo {
-            s_type: StructureType::IMAGE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: ImageCreateFlags::default(),
             image_type: ImageType::default(),
@@ -3280,10 +3575,13 @@ impl ::std::default::Default for ImageCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for ImageCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CREATE_INFO;
+}
 impl ImageCreateInfo {
     pub fn builder<'a>() -> ImageCreateInfoBuilder<'a> {
         ImageCreateInfoBuilder {
-            inner: ImageCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3306,51 +3604,63 @@ impl<'a> ::std::ops::DerefMut for ImageCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ImageCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn image_type(mut self, image_type: ImageType) -> Self {
         self.inner.image_type = image_type;
         self
     }
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn extent(mut self, extent: Extent3D) -> Self {
         self.inner.extent = extent;
         self
     }
+    #[inline]
     pub fn mip_levels(mut self, mip_levels: u32) -> Self {
         self.inner.mip_levels = mip_levels;
         self
     }
+    #[inline]
     pub fn array_layers(mut self, array_layers: u32) -> Self {
         self.inner.array_layers = array_layers;
         self
     }
+    #[inline]
     pub fn samples(mut self, samples: SampleCountFlags) -> Self {
         self.inner.samples = samples;
         self
     }
+    #[inline]
     pub fn tiling(mut self, tiling: ImageTiling) -> Self {
         self.inner.tiling = tiling;
         self
     }
+    #[inline]
     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
         self.inner.usage = usage;
         self
     }
+    #[inline]
     pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
         self.inner.sharing_mode = sharing_mode;
         self
     }
+    #[inline]
     pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
         self.inner.queue_family_index_count = queue_family_indices.len() as _;
         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
         self
     }
+    #[inline]
     pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
         self.inner.initial_layout = initial_layout;
         self
@@ -3362,10 +3672,10 @@ impl<'a> ImageCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsImageCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -3377,8 +3687,9 @@ impl<'a> ImageCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubresourceLayout.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout.html>"]
 pub struct SubresourceLayout {
     pub offset: DeviceSize,
     pub size: DeviceSize,
@@ -3389,7 +3700,7 @@ pub struct SubresourceLayout {
 impl SubresourceLayout {
     pub fn builder<'a>() -> SubresourceLayoutBuilder<'a> {
         SubresourceLayoutBuilder {
-            inner: SubresourceLayout::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3411,22 +3722,27 @@ impl<'a> ::std::ops::DerefMut for SubresourceLayoutBuilder<'a> {
     }
 }
 impl<'a> SubresourceLayoutBuilder<'a> {
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
     }
+    #[inline]
     pub fn row_pitch(mut self, row_pitch: DeviceSize) -> Self {
         self.inner.row_pitch = row_pitch;
         self
     }
+    #[inline]
     pub fn array_pitch(mut self, array_pitch: DeviceSize) -> Self {
         self.inner.array_pitch = array_pitch;
         self
     }
+    #[inline]
     pub fn depth_pitch(mut self, depth_pitch: DeviceSize) -> Self {
         self.inner.depth_pitch = depth_pitch;
         self
@@ -3439,8 +3755,9 @@ impl<'a> SubresourceLayoutBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCreateInfo.html>"]
 pub struct ImageViewCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -3452,9 +3769,10 @@ pub struct ImageViewCreateInfo {
     pub subresource_range: ImageSubresourceRange,
 }
 impl ::std::default::Default for ImageViewCreateInfo {
-    fn default() -> ImageViewCreateInfo {
-        ImageViewCreateInfo {
-            s_type: StructureType::IMAGE_VIEW_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: ImageViewCreateFlags::default(),
             image: Image::default(),
@@ -3465,10 +3783,13 @@ impl ::std::default::Default for ImageViewCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for ImageViewCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_CREATE_INFO;
+}
 impl ImageViewCreateInfo {
     pub fn builder<'a>() -> ImageViewCreateInfoBuilder<'a> {
         ImageViewCreateInfoBuilder {
-            inner: ImageViewCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3491,26 +3812,32 @@ impl<'a> ::std::ops::DerefMut for ImageViewCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ImageViewCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: ImageViewCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
     }
+    #[inline]
     pub fn view_type(mut self, view_type: ImageViewType) -> Self {
         self.inner.view_type = view_type;
         self
     }
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn components(mut self, components: ComponentMapping) -> Self {
         self.inner.components = components;
         self
     }
+    #[inline]
     pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
         self.inner.subresource_range = subresource_range;
         self
@@ -3522,10 +3849,10 @@ impl<'a> ImageViewCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsImageViewCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -3537,8 +3864,9 @@ impl<'a> ImageViewCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCopy.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy.html>"]
 pub struct BufferCopy {
     pub src_offset: DeviceSize,
     pub dst_offset: DeviceSize,
@@ -3547,7 +3875,7 @@ pub struct BufferCopy {
 impl BufferCopy {
     pub fn builder<'a>() -> BufferCopyBuilder<'a> {
         BufferCopyBuilder {
-            inner: BufferCopy::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3569,14 +3897,17 @@ impl<'a> ::std::ops::DerefMut for BufferCopyBuilder<'a> {
     }
 }
 impl<'a> BufferCopyBuilder<'a> {
+    #[inline]
     pub fn src_offset(mut self, src_offset: DeviceSize) -> Self {
         self.inner.src_offset = src_offset;
         self
     }
+    #[inline]
     pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self {
         self.inner.dst_offset = dst_offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
@@ -3589,8 +3920,9 @@ impl<'a> BufferCopyBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseMemoryBind.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseMemoryBind.html>"]
 pub struct SparseMemoryBind {
     pub resource_offset: DeviceSize,
     pub size: DeviceSize,
@@ -3601,7 +3933,7 @@ pub struct SparseMemoryBind {
 impl SparseMemoryBind {
     pub fn builder<'a>() -> SparseMemoryBindBuilder<'a> {
         SparseMemoryBindBuilder {
-            inner: SparseMemoryBind::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3623,22 +3955,27 @@ impl<'a> ::std::ops::DerefMut for SparseMemoryBindBuilder<'a> {
     }
 }
 impl<'a> SparseMemoryBindBuilder<'a> {
+    #[inline]
     pub fn resource_offset(mut self, resource_offset: DeviceSize) -> Self {
         self.inner.resource_offset = resource_offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
     }
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
         self.inner.memory_offset = memory_offset;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self {
         self.inner.flags = flags;
         self
@@ -3651,8 +3988,9 @@ impl<'a> SparseMemoryBindBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryBind.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBind.html>"]
 pub struct SparseImageMemoryBind {
     pub subresource: ImageSubresource,
     pub offset: Offset3D,
@@ -3664,7 +4002,7 @@ pub struct SparseImageMemoryBind {
 impl SparseImageMemoryBind {
     pub fn builder<'a>() -> SparseImageMemoryBindBuilder<'a> {
         SparseImageMemoryBindBuilder {
-            inner: SparseImageMemoryBind::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3686,26 +4024,32 @@ impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindBuilder<'a> {
     }
 }
 impl<'a> SparseImageMemoryBindBuilder<'a> {
+    #[inline]
     pub fn subresource(mut self, subresource: ImageSubresource) -> Self {
         self.inner.subresource = subresource;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: Offset3D) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn extent(mut self, extent: Extent3D) -> Self {
         self.inner.extent = extent;
         self
     }
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
         self.inner.memory_offset = memory_offset;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: SparseMemoryBindFlags) -> Self {
         self.inner.flags = flags;
         self
@@ -3718,16 +4062,18 @@ impl<'a> SparseImageMemoryBindBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseBufferMemoryBindInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseBufferMemoryBindInfo.html>"]
 pub struct SparseBufferMemoryBindInfo {
     pub buffer: Buffer,
     pub bind_count: u32,
     pub p_binds: *const SparseMemoryBind,
 }
 impl ::std::default::Default for SparseBufferMemoryBindInfo {
-    fn default() -> SparseBufferMemoryBindInfo {
-        SparseBufferMemoryBindInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
             buffer: Buffer::default(),
             bind_count: u32::default(),
             p_binds: ::std::ptr::null(),
@@ -3737,7 +4083,7 @@ impl ::std::default::Default for SparseBufferMemoryBindInfo {
 impl SparseBufferMemoryBindInfo {
     pub fn builder<'a>() -> SparseBufferMemoryBindInfoBuilder<'a> {
         SparseBufferMemoryBindInfoBuilder {
-            inner: SparseBufferMemoryBindInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3759,10 +4105,12 @@ impl<'a> ::std::ops::DerefMut for SparseBufferMemoryBindInfoBuilder<'a> {
     }
 }
 impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
     }
+    #[inline]
     pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self {
         self.inner.bind_count = binds.len() as _;
         self.inner.p_binds = binds.as_ptr();
@@ -3776,16 +4124,18 @@ impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageOpaqueMemoryBindInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageOpaqueMemoryBindInfo.html>"]
 pub struct SparseImageOpaqueMemoryBindInfo {
     pub image: Image,
     pub bind_count: u32,
     pub p_binds: *const SparseMemoryBind,
 }
 impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo {
-    fn default() -> SparseImageOpaqueMemoryBindInfo {
-        SparseImageOpaqueMemoryBindInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
             image: Image::default(),
             bind_count: u32::default(),
             p_binds: ::std::ptr::null(),
@@ -3795,7 +4145,7 @@ impl ::std::default::Default for SparseImageOpaqueMemoryBindInfo {
 impl SparseImageOpaqueMemoryBindInfo {
     pub fn builder<'a>() -> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
         SparseImageOpaqueMemoryBindInfoBuilder {
-            inner: SparseImageOpaqueMemoryBindInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3817,10 +4167,12 @@ impl<'a> ::std::ops::DerefMut for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
     }
 }
 impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
     }
+    #[inline]
     pub fn binds(mut self, binds: &'a [SparseMemoryBind]) -> Self {
         self.inner.bind_count = binds.len() as _;
         self.inner.p_binds = binds.as_ptr();
@@ -3834,16 +4186,18 @@ impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryBindInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryBindInfo.html>"]
 pub struct SparseImageMemoryBindInfo {
     pub image: Image,
     pub bind_count: u32,
     pub p_binds: *const SparseImageMemoryBind,
 }
 impl ::std::default::Default for SparseImageMemoryBindInfo {
-    fn default() -> SparseImageMemoryBindInfo {
-        SparseImageMemoryBindInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
             image: Image::default(),
             bind_count: u32::default(),
             p_binds: ::std::ptr::null(),
@@ -3853,7 +4207,7 @@ impl ::std::default::Default for SparseImageMemoryBindInfo {
 impl SparseImageMemoryBindInfo {
     pub fn builder<'a>() -> SparseImageMemoryBindInfoBuilder<'a> {
         SparseImageMemoryBindInfoBuilder {
-            inner: SparseImageMemoryBindInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3875,10 +4229,12 @@ impl<'a> ::std::ops::DerefMut for SparseImageMemoryBindInfoBuilder<'a> {
     }
 }
 impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
     }
+    #[inline]
     pub fn binds(mut self, binds: &'a [SparseImageMemoryBind]) -> Self {
         self.inner.bind_count = binds.len() as _;
         self.inner.p_binds = binds.as_ptr();
@@ -3892,8 +4248,9 @@ impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindSparseInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindSparseInfo.html>"]
 pub struct BindSparseInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -3909,9 +4266,10 @@ pub struct BindSparseInfo {
     pub p_signal_semaphores: *const Semaphore,
 }
 impl ::std::default::Default for BindSparseInfo {
-    fn default() -> BindSparseInfo {
-        BindSparseInfo {
-            s_type: StructureType::BIND_SPARSE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             wait_semaphore_count: u32::default(),
             p_wait_semaphores: ::std::ptr::null(),
@@ -3926,10 +4284,13 @@ impl ::std::default::Default for BindSparseInfo {
         }
     }
 }
+unsafe impl TaggedStructure for BindSparseInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BIND_SPARSE_INFO;
+}
 impl BindSparseInfo {
     pub fn builder<'a>() -> BindSparseInfoBuilder<'a> {
         BindSparseInfoBuilder {
-            inner: BindSparseInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -3952,16 +4313,19 @@ impl<'a> ::std::ops::DerefMut for BindSparseInfoBuilder<'a> {
     }
 }
 impl<'a> BindSparseInfoBuilder<'a> {
+    #[inline]
     pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
         self.inner.wait_semaphore_count = wait_semaphores.len() as _;
         self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
         self
     }
+    #[inline]
     pub fn buffer_binds(mut self, buffer_binds: &'a [SparseBufferMemoryBindInfo]) -> Self {
         self.inner.buffer_bind_count = buffer_binds.len() as _;
         self.inner.p_buffer_binds = buffer_binds.as_ptr();
         self
     }
+    #[inline]
     pub fn image_opaque_binds(
         mut self,
         image_opaque_binds: &'a [SparseImageOpaqueMemoryBindInfo],
@@ -3970,11 +4334,13 @@ impl<'a> BindSparseInfoBuilder<'a> {
         self.inner.p_image_opaque_binds = image_opaque_binds.as_ptr();
         self
     }
+    #[inline]
     pub fn image_binds(mut self, image_binds: &'a [SparseImageMemoryBindInfo]) -> Self {
         self.inner.image_bind_count = image_binds.len() as _;
         self.inner.p_image_binds = image_binds.as_ptr();
         self
     }
+    #[inline]
     pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self {
         self.inner.signal_semaphore_count = signal_semaphores.len() as _;
         self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
@@ -3987,10 +4353,10 @@ impl<'a> BindSparseInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsBindSparseInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -4002,8 +4368,9 @@ impl<'a> BindSparseInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCopy.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy.html>"]
 pub struct ImageCopy {
     pub src_subresource: ImageSubresourceLayers,
     pub src_offset: Offset3D,
@@ -4014,7 +4381,7 @@ pub struct ImageCopy {
 impl ImageCopy {
     pub fn builder<'a>() -> ImageCopyBuilder<'a> {
         ImageCopyBuilder {
-            inner: ImageCopy::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4036,22 +4403,27 @@ impl<'a> ::std::ops::DerefMut for ImageCopyBuilder<'a> {
     }
 }
 impl<'a> ImageCopyBuilder<'a> {
+    #[inline]
     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
         self.inner.src_subresource = src_subresource;
         self
     }
+    #[inline]
     pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
         self.inner.src_offset = src_offset;
         self
     }
+    #[inline]
     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
         self.inner.dst_subresource = dst_subresource;
         self
     }
+    #[inline]
     pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
         self.inner.dst_offset = dst_offset;
         self
     }
+    #[inline]
     pub fn extent(mut self, extent: Extent3D) -> Self {
         self.inner.extent = extent;
         self
@@ -4064,8 +4436,9 @@ impl<'a> ImageCopyBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageBlit.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit.html>"]
 pub struct ImageBlit {
     pub src_subresource: ImageSubresourceLayers,
     pub src_offsets: [Offset3D; 2],
@@ -4073,8 +4446,9 @@ pub struct ImageBlit {
     pub dst_offsets: [Offset3D; 2],
 }
 impl ::std::default::Default for ImageBlit {
-    fn default() -> ImageBlit {
-        ImageBlit {
+    #[inline]
+    fn default() -> Self {
+        Self {
             src_subresource: ImageSubresourceLayers::default(),
             src_offsets: unsafe { ::std::mem::zeroed() },
             dst_subresource: ImageSubresourceLayers::default(),
@@ -4085,7 +4459,7 @@ impl ::std::default::Default for ImageBlit {
 impl ImageBlit {
     pub fn builder<'a>() -> ImageBlitBuilder<'a> {
         ImageBlitBuilder {
-            inner: ImageBlit::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4107,18 +4481,22 @@ impl<'a> ::std::ops::DerefMut for ImageBlitBuilder<'a> {
     }
 }
 impl<'a> ImageBlitBuilder<'a> {
+    #[inline]
     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
         self.inner.src_subresource = src_subresource;
         self
     }
+    #[inline]
     pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self {
         self.inner.src_offsets = src_offsets;
         self
     }
+    #[inline]
     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
         self.inner.dst_subresource = dst_subresource;
         self
     }
+    #[inline]
     pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self {
         self.inner.dst_offsets = dst_offsets;
         self
@@ -4131,8 +4509,9 @@ impl<'a> ImageBlitBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferImageCopy.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy.html>"]
 pub struct BufferImageCopy {
     pub buffer_offset: DeviceSize,
     pub buffer_row_length: u32,
@@ -4144,7 +4523,7 @@ pub struct BufferImageCopy {
 impl BufferImageCopy {
     pub fn builder<'a>() -> BufferImageCopyBuilder<'a> {
         BufferImageCopyBuilder {
-            inner: BufferImageCopy::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4166,26 +4545,32 @@ impl<'a> ::std::ops::DerefMut for BufferImageCopyBuilder<'a> {
     }
 }
 impl<'a> BufferImageCopyBuilder<'a> {
+    #[inline]
     pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self {
         self.inner.buffer_offset = buffer_offset;
         self
     }
+    #[inline]
     pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
         self.inner.buffer_row_length = buffer_row_length;
         self
     }
+    #[inline]
     pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
         self.inner.buffer_image_height = buffer_image_height;
         self
     }
+    #[inline]
     pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
         self.inner.image_subresource = image_subresource;
         self
     }
+    #[inline]
     pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
         self.inner.image_offset = image_offset;
         self
     }
+    #[inline]
     pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
         self.inner.image_extent = image_extent;
         self
@@ -4198,8 +4583,139 @@ impl<'a> BufferImageCopyBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageResolve.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryIndirectCommandNV.html>"]
+pub struct CopyMemoryIndirectCommandNV {
+    pub src_address: DeviceAddress,
+    pub dst_address: DeviceAddress,
+    pub size: DeviceSize,
+}
+impl CopyMemoryIndirectCommandNV {
+    pub fn builder<'a>() -> CopyMemoryIndirectCommandNVBuilder<'a> {
+        CopyMemoryIndirectCommandNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct CopyMemoryIndirectCommandNVBuilder<'a> {
+    inner: CopyMemoryIndirectCommandNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for CopyMemoryIndirectCommandNVBuilder<'a> {
+    type Target = CopyMemoryIndirectCommandNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for CopyMemoryIndirectCommandNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> CopyMemoryIndirectCommandNVBuilder<'a> {
+    #[inline]
+    pub fn src_address(mut self, src_address: DeviceAddress) -> Self {
+        self.inner.src_address = src_address;
+        self
+    }
+    #[inline]
+    pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self {
+        self.inner.dst_address = dst_address;
+        self
+    }
+    #[inline]
+    pub fn size(mut self, size: DeviceSize) -> Self {
+        self.inner.size = size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> CopyMemoryIndirectCommandNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToImageIndirectCommandNV.html>"]
+pub struct CopyMemoryToImageIndirectCommandNV {
+    pub src_address: DeviceAddress,
+    pub buffer_row_length: u32,
+    pub buffer_image_height: u32,
+    pub image_subresource: ImageSubresourceLayers,
+    pub image_offset: Offset3D,
+    pub image_extent: Extent3D,
+}
+impl CopyMemoryToImageIndirectCommandNV {
+    pub fn builder<'a>() -> CopyMemoryToImageIndirectCommandNVBuilder<'a> {
+        CopyMemoryToImageIndirectCommandNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct CopyMemoryToImageIndirectCommandNVBuilder<'a> {
+    inner: CopyMemoryToImageIndirectCommandNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for CopyMemoryToImageIndirectCommandNVBuilder<'a> {
+    type Target = CopyMemoryToImageIndirectCommandNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for CopyMemoryToImageIndirectCommandNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> CopyMemoryToImageIndirectCommandNVBuilder<'a> {
+    #[inline]
+    pub fn src_address(mut self, src_address: DeviceAddress) -> Self {
+        self.inner.src_address = src_address;
+        self
+    }
+    #[inline]
+    pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
+        self.inner.buffer_row_length = buffer_row_length;
+        self
+    }
+    #[inline]
+    pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
+        self.inner.buffer_image_height = buffer_image_height;
+        self
+    }
+    #[inline]
+    pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
+        self.inner.image_subresource = image_subresource;
+        self
+    }
+    #[inline]
+    pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
+        self.inner.image_offset = image_offset;
+        self
+    }
+    #[inline]
+    pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
+        self.inner.image_extent = image_extent;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> CopyMemoryToImageIndirectCommandNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve.html>"]
 pub struct ImageResolve {
     pub src_subresource: ImageSubresourceLayers,
     pub src_offset: Offset3D,
@@ -4210,7 +4726,7 @@ pub struct ImageResolve {
 impl ImageResolve {
     pub fn builder<'a>() -> ImageResolveBuilder<'a> {
         ImageResolveBuilder {
-            inner: ImageResolve::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4232,22 +4748,27 @@ impl<'a> ::std::ops::DerefMut for ImageResolveBuilder<'a> {
     }
 }
 impl<'a> ImageResolveBuilder<'a> {
+    #[inline]
     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
         self.inner.src_subresource = src_subresource;
         self
     }
+    #[inline]
     pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
         self.inner.src_offset = src_offset;
         self
     }
+    #[inline]
     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
         self.inner.dst_subresource = dst_subresource;
         self
     }
+    #[inline]
     pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
         self.inner.dst_offset = dst_offset;
         self
     }
+    #[inline]
     pub fn extent(mut self, extent: Extent3D) -> Self {
         self.inner.extent = extent;
         self
@@ -4260,8 +4781,9 @@ impl<'a> ImageResolveBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleCreateInfo.html>"]
 pub struct ShaderModuleCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -4270,9 +4792,10 @@ pub struct ShaderModuleCreateInfo {
     pub p_code: *const u32,
 }
 impl ::std::default::Default for ShaderModuleCreateInfo {
-    fn default() -> ShaderModuleCreateInfo {
-        ShaderModuleCreateInfo {
-            s_type: StructureType::SHADER_MODULE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: ShaderModuleCreateFlags::default(),
             code_size: usize::default(),
@@ -4280,10 +4803,13 @@ impl ::std::default::Default for ShaderModuleCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for ShaderModuleCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_CREATE_INFO;
+}
 impl ShaderModuleCreateInfo {
     pub fn builder<'a>() -> ShaderModuleCreateInfoBuilder<'a> {
         ShaderModuleCreateInfoBuilder {
-            inner: ShaderModuleCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4293,6 +4819,8 @@ pub struct ShaderModuleCreateInfoBuilder<'a> {
     inner: ShaderModuleCreateInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleCreateInfoBuilder<'_> {}
+unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleCreateInfo {}
 pub unsafe trait ExtendsShaderModuleCreateInfo {}
 impl<'a> ::std::ops::Deref for ShaderModuleCreateInfoBuilder<'a> {
     type Target = ShaderModuleCreateInfo;
@@ -4306,13 +4834,15 @@ impl<'a> ::std::ops::DerefMut for ShaderModuleCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ShaderModuleCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: ShaderModuleCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn code(mut self, code: &'a [u32]) -> Self {
         self.inner.code_size = code.len() * 4;
-        self.inner.p_code = code.as_ptr() as *const u32;
+        self.inner.p_code = code.as_ptr();
         self
     }
     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
@@ -4322,10 +4852,10 @@ impl<'a> ShaderModuleCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsShaderModuleCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -4337,8 +4867,9 @@ impl<'a> ShaderModuleCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutBinding.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBinding.html>"]
 pub struct DescriptorSetLayoutBinding {
     pub binding: u32,
     pub descriptor_type: DescriptorType,
@@ -4347,8 +4878,9 @@ pub struct DescriptorSetLayoutBinding {
     pub p_immutable_samplers: *const Sampler,
 }
 impl ::std::default::Default for DescriptorSetLayoutBinding {
-    fn default() -> DescriptorSetLayoutBinding {
-        DescriptorSetLayoutBinding {
+    #[inline]
+    fn default() -> Self {
+        Self {
             binding: u32::default(),
             descriptor_type: DescriptorType::default(),
             descriptor_count: u32::default(),
@@ -4360,7 +4892,7 @@ impl ::std::default::Default for DescriptorSetLayoutBinding {
 impl DescriptorSetLayoutBinding {
     pub fn builder<'a>() -> DescriptorSetLayoutBindingBuilder<'a> {
         DescriptorSetLayoutBindingBuilder {
-            inner: DescriptorSetLayoutBinding::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4382,22 +4914,27 @@ impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingBuilder<'a> {
     }
 }
 impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
+    #[inline]
     pub fn binding(mut self, binding: u32) -> Self {
         self.inner.binding = binding;
         self
     }
+    #[inline]
     pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
         self.inner.descriptor_type = descriptor_type;
         self
     }
+    #[inline]
     pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
         self.inner.descriptor_count = descriptor_count;
         self
     }
+    #[inline]
     pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self {
         self.inner.stage_flags = stage_flags;
         self
     }
+    #[inline]
     pub fn immutable_samplers(mut self, immutable_samplers: &'a [Sampler]) -> Self {
         self.inner.descriptor_count = immutable_samplers.len() as _;
         self.inner.p_immutable_samplers = immutable_samplers.as_ptr();
@@ -4411,8 +4948,9 @@ impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutCreateInfo.html>"]
 pub struct DescriptorSetLayoutCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -4421,9 +4959,10 @@ pub struct DescriptorSetLayoutCreateInfo {
     pub p_bindings: *const DescriptorSetLayoutBinding,
 }
 impl ::std::default::Default for DescriptorSetLayoutCreateInfo {
-    fn default() -> DescriptorSetLayoutCreateInfo {
-        DescriptorSetLayoutCreateInfo {
-            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DescriptorSetLayoutCreateFlags::default(),
             binding_count: u32::default(),
@@ -4431,10 +4970,13 @@ impl ::std::default::Default for DescriptorSetLayoutCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for DescriptorSetLayoutCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+}
 impl DescriptorSetLayoutCreateInfo {
     pub fn builder<'a>() -> DescriptorSetLayoutCreateInfoBuilder<'a> {
         DescriptorSetLayoutCreateInfoBuilder {
-            inner: DescriptorSetLayoutCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4457,10 +4999,12 @@ impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutCreateInfoBuilder<'a> {
     }
 }
 impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DescriptorSetLayoutCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn bindings(mut self, bindings: &'a [DescriptorSetLayoutBinding]) -> Self {
         self.inner.binding_count = bindings.len() as _;
         self.inner.p_bindings = bindings.as_ptr();
@@ -4473,10 +5017,10 @@ impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsDescriptorSetLayoutCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -4488,8 +5032,9 @@ impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolSize.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolSize.html>"]
 pub struct DescriptorPoolSize {
     pub ty: DescriptorType,
     pub descriptor_count: u32,
@@ -4497,7 +5042,7 @@ pub struct DescriptorPoolSize {
 impl DescriptorPoolSize {
     pub fn builder<'a>() -> DescriptorPoolSizeBuilder<'a> {
         DescriptorPoolSizeBuilder {
-            inner: DescriptorPoolSize::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4519,10 +5064,12 @@ impl<'a> ::std::ops::DerefMut for DescriptorPoolSizeBuilder<'a> {
     }
 }
 impl<'a> DescriptorPoolSizeBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: DescriptorType) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
         self.inner.descriptor_count = descriptor_count;
         self
@@ -4535,8 +5082,9 @@ impl<'a> DescriptorPoolSizeBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolCreateInfo.html>"]
 pub struct DescriptorPoolCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -4546,9 +5094,10 @@ pub struct DescriptorPoolCreateInfo {
     pub p_pool_sizes: *const DescriptorPoolSize,
 }
 impl ::std::default::Default for DescriptorPoolCreateInfo {
-    fn default() -> DescriptorPoolCreateInfo {
-        DescriptorPoolCreateInfo {
-            s_type: StructureType::DESCRIPTOR_POOL_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DescriptorPoolCreateFlags::default(),
             max_sets: u32::default(),
@@ -4557,10 +5106,13 @@ impl ::std::default::Default for DescriptorPoolCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for DescriptorPoolCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_POOL_CREATE_INFO;
+}
 impl DescriptorPoolCreateInfo {
     pub fn builder<'a>() -> DescriptorPoolCreateInfoBuilder<'a> {
         DescriptorPoolCreateInfoBuilder {
-            inner: DescriptorPoolCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4583,14 +5135,17 @@ impl<'a> ::std::ops::DerefMut for DescriptorPoolCreateInfoBuilder<'a> {
     }
 }
 impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DescriptorPoolCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn max_sets(mut self, max_sets: u32) -> Self {
         self.inner.max_sets = max_sets;
         self
     }
+    #[inline]
     pub fn pool_sizes(mut self, pool_sizes: &'a [DescriptorPoolSize]) -> Self {
         self.inner.pool_size_count = pool_sizes.len() as _;
         self.inner.p_pool_sizes = pool_sizes.as_ptr();
@@ -4603,10 +5158,10 @@ impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsDescriptorPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -4618,8 +5173,9 @@ impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetAllocateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetAllocateInfo.html>"]
 pub struct DescriptorSetAllocateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -4628,9 +5184,10 @@ pub struct DescriptorSetAllocateInfo {
     pub p_set_layouts: *const DescriptorSetLayout,
 }
 impl ::std::default::Default for DescriptorSetAllocateInfo {
-    fn default() -> DescriptorSetAllocateInfo {
-        DescriptorSetAllocateInfo {
-            s_type: StructureType::DESCRIPTOR_SET_ALLOCATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             descriptor_pool: DescriptorPool::default(),
             descriptor_set_count: u32::default(),
@@ -4638,10 +5195,13 @@ impl ::std::default::Default for DescriptorSetAllocateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for DescriptorSetAllocateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_ALLOCATE_INFO;
+}
 impl DescriptorSetAllocateInfo {
     pub fn builder<'a>() -> DescriptorSetAllocateInfoBuilder<'a> {
         DescriptorSetAllocateInfoBuilder {
-            inner: DescriptorSetAllocateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4664,10 +5224,12 @@ impl<'a> ::std::ops::DerefMut for DescriptorSetAllocateInfoBuilder<'a> {
     }
 }
 impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
+    #[inline]
     pub fn descriptor_pool(mut self, descriptor_pool: DescriptorPool) -> Self {
         self.inner.descriptor_pool = descriptor_pool;
         self
     }
+    #[inline]
     pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
         self.inner.descriptor_set_count = set_layouts.len() as _;
         self.inner.p_set_layouts = set_layouts.as_ptr();
@@ -4680,10 +5242,10 @@ impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsDescriptorSetAllocateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -4695,8 +5257,9 @@ impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSpecializationMapEntry.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationMapEntry.html>"]
 pub struct SpecializationMapEntry {
     pub constant_id: u32,
     pub offset: u32,
@@ -4705,7 +5268,7 @@ pub struct SpecializationMapEntry {
 impl SpecializationMapEntry {
     pub fn builder<'a>() -> SpecializationMapEntryBuilder<'a> {
         SpecializationMapEntryBuilder {
-            inner: SpecializationMapEntry::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4727,14 +5290,17 @@ impl<'a> ::std::ops::DerefMut for SpecializationMapEntryBuilder<'a> {
     }
 }
 impl<'a> SpecializationMapEntryBuilder<'a> {
+    #[inline]
     pub fn constant_id(mut self, constant_id: u32) -> Self {
         self.inner.constant_id = constant_id;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: u32) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: usize) -> Self {
         self.inner.size = size;
         self
@@ -4747,8 +5313,9 @@ impl<'a> SpecializationMapEntryBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSpecializationInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSpecializationInfo.html>"]
 pub struct SpecializationInfo {
     pub map_entry_count: u32,
     pub p_map_entries: *const SpecializationMapEntry,
@@ -4756,8 +5323,9 @@ pub struct SpecializationInfo {
     pub p_data: *const c_void,
 }
 impl ::std::default::Default for SpecializationInfo {
-    fn default() -> SpecializationInfo {
-        SpecializationInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
             map_entry_count: u32::default(),
             p_map_entries: ::std::ptr::null(),
             data_size: usize::default(),
@@ -4768,7 +5336,7 @@ impl ::std::default::Default for SpecializationInfo {
 impl SpecializationInfo {
     pub fn builder<'a>() -> SpecializationInfoBuilder<'a> {
         SpecializationInfoBuilder {
-            inner: SpecializationInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4790,14 +5358,16 @@ impl<'a> ::std::ops::DerefMut for SpecializationInfoBuilder<'a> {
     }
 }
 impl<'a> SpecializationInfoBuilder<'a> {
+    #[inline]
     pub fn map_entries(mut self, map_entries: &'a [SpecializationMapEntry]) -> Self {
         self.inner.map_entry_count = map_entries.len() as _;
         self.inner.p_map_entries = map_entries.as_ptr();
         self
     }
+    #[inline]
     pub fn data(mut self, data: &'a [u8]) -> Self {
-        self.inner.data_size = data.len() as _;
-        self.inner.p_data = data.as_ptr() as *const c_void;
+        self.inner.data_size = data.len();
+        self.inner.p_data = data.as_ptr().cast();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -4808,8 +5378,9 @@ impl<'a> SpecializationInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageCreateInfo.html>"]
 pub struct PipelineShaderStageCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -4820,9 +5391,10 @@ pub struct PipelineShaderStageCreateInfo {
     pub p_specialization_info: *const SpecializationInfo,
 }
 impl ::std::default::Default for PipelineShaderStageCreateInfo {
-    fn default() -> PipelineShaderStageCreateInfo {
-        PipelineShaderStageCreateInfo {
-            s_type: StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineShaderStageCreateFlags::default(),
             stage: ShaderStageFlags::default(),
@@ -4832,10 +5404,13 @@ impl ::std::default::Default for PipelineShaderStageCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineShaderStageCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_SHADER_STAGE_CREATE_INFO;
+}
 impl PipelineShaderStageCreateInfo {
     pub fn builder<'a>() -> PipelineShaderStageCreateInfoBuilder<'a> {
         PipelineShaderStageCreateInfoBuilder {
-            inner: PipelineShaderStageCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4858,22 +5433,27 @@ impl<'a> ::std::ops::DerefMut for PipelineShaderStageCreateInfoBuilder<'a> {
     }
 }
 impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineShaderStageCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn stage(mut self, stage: ShaderStageFlags) -> Self {
         self.inner.stage = stage;
         self
     }
+    #[inline]
     pub fn module(mut self, module: ShaderModule) -> Self {
         self.inner.module = module;
         self
     }
+    #[inline]
     pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_name = name.as_ptr();
         self
     }
+    #[inline]
     pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self {
         self.inner.p_specialization_info = specialization_info;
         self
@@ -4885,10 +5465,10 @@ impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsPipelineShaderStageCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -4900,8 +5480,9 @@ impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkComputePipelineCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComputePipelineCreateInfo.html>"]
 pub struct ComputePipelineCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -4912,9 +5493,10 @@ pub struct ComputePipelineCreateInfo {
     pub base_pipeline_index: i32,
 }
 impl ::std::default::Default for ComputePipelineCreateInfo {
-    fn default() -> ComputePipelineCreateInfo {
-        ComputePipelineCreateInfo {
-            s_type: StructureType::COMPUTE_PIPELINE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineCreateFlags::default(),
             stage: PipelineShaderStageCreateInfo::default(),
@@ -4924,10 +5506,13 @@ impl ::std::default::Default for ComputePipelineCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for ComputePipelineCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::COMPUTE_PIPELINE_CREATE_INFO;
+}
 impl ComputePipelineCreateInfo {
     pub fn builder<'a>() -> ComputePipelineCreateInfoBuilder<'a> {
         ComputePipelineCreateInfoBuilder {
-            inner: ComputePipelineCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -4950,22 +5535,27 @@ impl<'a> ::std::ops::DerefMut for ComputePipelineCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ComputePipelineCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn stage(mut self, stage: PipelineShaderStageCreateInfo) -> Self {
         self.inner.stage = stage;
         self
     }
+    #[inline]
     pub fn layout(mut self, layout: PipelineLayout) -> Self {
         self.inner.layout = layout;
         self
     }
+    #[inline]
     pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
         self.inner.base_pipeline_handle = base_pipeline_handle;
         self
     }
+    #[inline]
     pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
         self.inner.base_pipeline_index = base_pipeline_index;
         self
@@ -4977,10 +5567,10 @@ impl<'a> ComputePipelineCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsComputePipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -4992,8 +5582,9 @@ impl<'a> ComputePipelineCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputBindingDescription.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription.html>"]
 pub struct VertexInputBindingDescription {
     pub binding: u32,
     pub stride: u32,
@@ -5002,7 +5593,7 @@ pub struct VertexInputBindingDescription {
 impl VertexInputBindingDescription {
     pub fn builder<'a>() -> VertexInputBindingDescriptionBuilder<'a> {
         VertexInputBindingDescriptionBuilder {
-            inner: VertexInputBindingDescription::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5024,14 +5615,17 @@ impl<'a> ::std::ops::DerefMut for VertexInputBindingDescriptionBuilder<'a> {
     }
 }
 impl<'a> VertexInputBindingDescriptionBuilder<'a> {
+    #[inline]
     pub fn binding(mut self, binding: u32) -> Self {
         self.inner.binding = binding;
         self
     }
+    #[inline]
     pub fn stride(mut self, stride: u32) -> Self {
         self.inner.stride = stride;
         self
     }
+    #[inline]
     pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self {
         self.inner.input_rate = input_rate;
         self
@@ -5044,8 +5638,9 @@ impl<'a> VertexInputBindingDescriptionBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputAttributeDescription.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription.html>"]
 pub struct VertexInputAttributeDescription {
     pub location: u32,
     pub binding: u32,
@@ -5055,7 +5650,7 @@ pub struct VertexInputAttributeDescription {
 impl VertexInputAttributeDescription {
     pub fn builder<'a>() -> VertexInputAttributeDescriptionBuilder<'a> {
         VertexInputAttributeDescriptionBuilder {
-            inner: VertexInputAttributeDescription::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5077,18 +5672,22 @@ impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescriptionBuilder<'a> {
     }
 }
 impl<'a> VertexInputAttributeDescriptionBuilder<'a> {
+    #[inline]
     pub fn location(mut self, location: u32) -> Self {
         self.inner.location = location;
         self
     }
+    #[inline]
     pub fn binding(mut self, binding: u32) -> Self {
         self.inner.binding = binding;
         self
     }
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: u32) -> Self {
         self.inner.offset = offset;
         self
@@ -5101,8 +5700,9 @@ impl<'a> VertexInputAttributeDescriptionBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputStateCreateInfo.html>"]
 pub struct PipelineVertexInputStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -5113,9 +5713,10 @@ pub struct PipelineVertexInputStateCreateInfo {
     pub p_vertex_attribute_descriptions: *const VertexInputAttributeDescription,
 }
 impl ::std::default::Default for PipelineVertexInputStateCreateInfo {
-    fn default() -> PipelineVertexInputStateCreateInfo {
-        PipelineVertexInputStateCreateInfo {
-            s_type: StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineVertexInputStateCreateFlags::default(),
             vertex_binding_description_count: u32::default(),
@@ -5125,10 +5726,13 @@ impl ::std::default::Default for PipelineVertexInputStateCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineVertexInputStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+}
 impl PipelineVertexInputStateCreateInfo {
     pub fn builder<'a>() -> PipelineVertexInputStateCreateInfoBuilder<'a> {
         PipelineVertexInputStateCreateInfoBuilder {
-            inner: PipelineVertexInputStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5151,10 +5755,12 @@ impl<'a> ::std::ops::DerefMut for PipelineVertexInputStateCreateInfoBuilder<'a>
     }
 }
 impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineVertexInputStateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn vertex_binding_descriptions(
         mut self,
         vertex_binding_descriptions: &'a [VertexInputBindingDescription],
@@ -5163,6 +5769,7 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
         self.inner.p_vertex_binding_descriptions = vertex_binding_descriptions.as_ptr();
         self
     }
+    #[inline]
     pub fn vertex_attribute_descriptions(
         mut self,
         vertex_attribute_descriptions: &'a [VertexInputAttributeDescription],
@@ -5181,10 +5788,10 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -5196,8 +5803,9 @@ impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInputAssemblyStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInputAssemblyStateCreateInfo.html>"]
 pub struct PipelineInputAssemblyStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -5206,9 +5814,10 @@ pub struct PipelineInputAssemblyStateCreateInfo {
     pub primitive_restart_enable: Bool32,
 }
 impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo {
-    fn default() -> PipelineInputAssemblyStateCreateInfo {
-        PipelineInputAssemblyStateCreateInfo {
-            s_type: StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineInputAssemblyStateCreateFlags::default(),
             topology: PrimitiveTopology::default(),
@@ -5216,10 +5825,13 @@ impl ::std::default::Default for PipelineInputAssemblyStateCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineInputAssemblyStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+}
 impl PipelineInputAssemblyStateCreateInfo {
     pub fn builder<'a>() -> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
         PipelineInputAssemblyStateCreateInfoBuilder {
-            inner: PipelineInputAssemblyStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5241,14 +5853,17 @@ impl<'a> ::std::ops::DerefMut for PipelineInputAssemblyStateCreateInfoBuilder<'a
     }
 }
 impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineInputAssemblyStateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn topology(mut self, topology: PrimitiveTopology) -> Self {
         self.inner.topology = topology;
         self
     }
+    #[inline]
     pub fn primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self {
         self.inner.primitive_restart_enable = primitive_restart_enable.into();
         self
@@ -5261,8 +5876,9 @@ impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationStateCreateInfo.html>"]
 pub struct PipelineTessellationStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -5270,19 +5886,23 @@ pub struct PipelineTessellationStateCreateInfo {
     pub patch_control_points: u32,
 }
 impl ::std::default::Default for PipelineTessellationStateCreateInfo {
-    fn default() -> PipelineTessellationStateCreateInfo {
-        PipelineTessellationStateCreateInfo {
-            s_type: StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineTessellationStateCreateFlags::default(),
             patch_control_points: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineTessellationStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_TESSELLATION_STATE_CREATE_INFO;
+}
 impl PipelineTessellationStateCreateInfo {
     pub fn builder<'a>() -> PipelineTessellationStateCreateInfoBuilder<'a> {
         PipelineTessellationStateCreateInfoBuilder {
-            inner: PipelineTessellationStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5305,10 +5925,12 @@ impl<'a> ::std::ops::DerefMut for PipelineTessellationStateCreateInfoBuilder<'a>
     }
 }
 impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineTessellationStateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn patch_control_points(mut self, patch_control_points: u32) -> Self {
         self.inner.patch_control_points = patch_control_points;
         self
@@ -5323,10 +5945,10 @@ impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -5338,8 +5960,9 @@ impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportStateCreateInfo.html>"]
 pub struct PipelineViewportStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -5350,9 +5973,10 @@ pub struct PipelineViewportStateCreateInfo {
     pub p_scissors: *const Rect2D,
 }
 impl ::std::default::Default for PipelineViewportStateCreateInfo {
-    fn default() -> PipelineViewportStateCreateInfo {
-        PipelineViewportStateCreateInfo {
-            s_type: StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineViewportStateCreateFlags::default(),
             viewport_count: u32::default(),
@@ -5362,10 +5986,13 @@ impl ::std::default::Default for PipelineViewportStateCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineViewportStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+}
 impl PipelineViewportStateCreateInfo {
     pub fn builder<'a>() -> PipelineViewportStateCreateInfoBuilder<'a> {
         PipelineViewportStateCreateInfoBuilder {
-            inner: PipelineViewportStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5388,23 +6015,28 @@ impl<'a> ::std::ops::DerefMut for PipelineViewportStateCreateInfoBuilder<'a> {
     }
 }
 impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineViewportStateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn viewport_count(mut self, viewport_count: u32) -> Self {
         self.inner.viewport_count = viewport_count;
         self
     }
+    #[inline]
     pub fn viewports(mut self, viewports: &'a [Viewport]) -> Self {
         self.inner.viewport_count = viewports.len() as _;
         self.inner.p_viewports = viewports.as_ptr();
         self
     }
+    #[inline]
     pub fn scissor_count(mut self, scissor_count: u32) -> Self {
         self.inner.scissor_count = scissor_count;
         self
     }
+    #[inline]
     pub fn scissors(mut self, scissors: &'a [Rect2D]) -> Self {
         self.inner.scissor_count = scissors.len() as _;
         self.inner.p_scissors = scissors.as_ptr();
@@ -5417,10 +6049,10 @@ impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsPipelineViewportStateCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -5432,8 +6064,9 @@ impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateCreateInfo.html>"]
 pub struct PipelineRasterizationStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -5450,9 +6083,10 @@ pub struct PipelineRasterizationStateCreateInfo {
     pub line_width: f32,
 }
 impl ::std::default::Default for PipelineRasterizationStateCreateInfo {
-    fn default() -> PipelineRasterizationStateCreateInfo {
-        PipelineRasterizationStateCreateInfo {
-            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineRasterizationStateCreateFlags::default(),
             depth_clamp_enable: Bool32::default(),
@@ -5468,10 +6102,13 @@ impl ::std::default::Default for PipelineRasterizationStateCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineRasterizationStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+}
 impl PipelineRasterizationStateCreateInfo {
     pub fn builder<'a>() -> PipelineRasterizationStateCreateInfoBuilder<'a> {
         PipelineRasterizationStateCreateInfoBuilder {
-            inner: PipelineRasterizationStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5494,46 +6131,57 @@ impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateCreateInfoBuilder<'a
     }
 }
 impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineRasterizationStateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self {
         self.inner.depth_clamp_enable = depth_clamp_enable.into();
         self
     }
+    #[inline]
     pub fn rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self {
         self.inner.rasterizer_discard_enable = rasterizer_discard_enable.into();
         self
     }
+    #[inline]
     pub fn polygon_mode(mut self, polygon_mode: PolygonMode) -> Self {
         self.inner.polygon_mode = polygon_mode;
         self
     }
+    #[inline]
     pub fn cull_mode(mut self, cull_mode: CullModeFlags) -> Self {
         self.inner.cull_mode = cull_mode;
         self
     }
+    #[inline]
     pub fn front_face(mut self, front_face: FrontFace) -> Self {
         self.inner.front_face = front_face;
         self
     }
+    #[inline]
     pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self {
         self.inner.depth_bias_enable = depth_bias_enable.into();
         self
     }
+    #[inline]
     pub fn depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self {
         self.inner.depth_bias_constant_factor = depth_bias_constant_factor;
         self
     }
+    #[inline]
     pub fn depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self {
         self.inner.depth_bias_clamp = depth_bias_clamp;
         self
     }
+    #[inline]
     pub fn depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self {
         self.inner.depth_bias_slope_factor = depth_bias_slope_factor;
         self
     }
+    #[inline]
     pub fn line_width(mut self, line_width: f32) -> Self {
         self.inner.line_width = line_width;
         self
@@ -5548,10 +6196,10 @@ impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -5563,8 +6211,9 @@ impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html>"]
 pub struct PipelineMultisampleStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -5577,9 +6226,10 @@ pub struct PipelineMultisampleStateCreateInfo {
     pub alpha_to_one_enable: Bool32,
 }
 impl ::std::default::Default for PipelineMultisampleStateCreateInfo {
-    fn default() -> PipelineMultisampleStateCreateInfo {
-        PipelineMultisampleStateCreateInfo {
-            s_type: StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineMultisampleStateCreateFlags::default(),
             rasterization_samples: SampleCountFlags::default(),
@@ -5591,10 +6241,13 @@ impl ::std::default::Default for PipelineMultisampleStateCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineMultisampleStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+}
 impl PipelineMultisampleStateCreateInfo {
     pub fn builder<'a>() -> PipelineMultisampleStateCreateInfoBuilder<'a> {
         PipelineMultisampleStateCreateInfoBuilder {
-            inner: PipelineMultisampleStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5617,18 +6270,22 @@ impl<'a> ::std::ops::DerefMut for PipelineMultisampleStateCreateInfoBuilder<'a>
     }
 }
 impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineMultisampleStateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
         self.inner.rasterization_samples = rasterization_samples;
         self
     }
+    #[inline]
     pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self {
         self.inner.sample_shading_enable = sample_shading_enable.into();
         self
     }
+    #[inline]
     pub fn min_sample_shading(mut self, min_sample_shading: f32) -> Self {
         self.inner.min_sample_shading = min_sample_shading;
         self
@@ -5636,20 +6293,23 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
     #[doc = r" Sets `p_sample_mask` to `null` if the slice is empty. The mask will"]
     #[doc = r" be treated as if it has all bits set to `1`."]
     #[doc = r""]
-    #[doc = r" See <https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html#_description>"]
+    #[doc = r" See <https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineMultisampleStateCreateInfo.html#_description>"]
     #[doc = r" for more details."]
+    #[inline]
     pub fn sample_mask(mut self, sample_mask: &'a [SampleMask]) -> Self {
         self.inner.p_sample_mask = if sample_mask.is_empty() {
             std::ptr::null()
         } else {
-            sample_mask.as_ptr() as *const SampleMask
+            sample_mask.as_ptr()
         };
         self
     }
+    #[inline]
     pub fn alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self {
         self.inner.alpha_to_coverage_enable = alpha_to_coverage_enable.into();
         self
     }
+    #[inline]
     pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self {
         self.inner.alpha_to_one_enable = alpha_to_one_enable.into();
         self
@@ -5664,10 +6324,10 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -5679,8 +6339,9 @@ impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendAttachmentState.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAttachmentState.html>"]
 pub struct PipelineColorBlendAttachmentState {
     pub blend_enable: Bool32,
     pub src_color_blend_factor: BlendFactor,
@@ -5694,7 +6355,7 @@ pub struct PipelineColorBlendAttachmentState {
 impl PipelineColorBlendAttachmentState {
     pub fn builder<'a>() -> PipelineColorBlendAttachmentStateBuilder<'a> {
         PipelineColorBlendAttachmentStateBuilder {
-            inner: PipelineColorBlendAttachmentState::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5716,34 +6377,42 @@ impl<'a> ::std::ops::DerefMut for PipelineColorBlendAttachmentStateBuilder<'a> {
     }
 }
 impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> {
+    #[inline]
     pub fn blend_enable(mut self, blend_enable: bool) -> Self {
         self.inner.blend_enable = blend_enable.into();
         self
     }
+    #[inline]
     pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self {
         self.inner.src_color_blend_factor = src_color_blend_factor;
         self
     }
+    #[inline]
     pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self {
         self.inner.dst_color_blend_factor = dst_color_blend_factor;
         self
     }
+    #[inline]
     pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self {
         self.inner.color_blend_op = color_blend_op;
         self
     }
+    #[inline]
     pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self {
         self.inner.src_alpha_blend_factor = src_alpha_blend_factor;
         self
     }
+    #[inline]
     pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self {
         self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor;
         self
     }
+    #[inline]
     pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self {
         self.inner.alpha_blend_op = alpha_blend_op;
         self
     }
+    #[inline]
     pub fn color_write_mask(mut self, color_write_mask: ColorComponentFlags) -> Self {
         self.inner.color_write_mask = color_write_mask;
         self
@@ -5756,8 +6425,9 @@ impl<'a> PipelineColorBlendAttachmentStateBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendStateCreateInfo.html>"]
 pub struct PipelineColorBlendStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -5769,9 +6439,10 @@ pub struct PipelineColorBlendStateCreateInfo {
     pub blend_constants: [f32; 4],
 }
 impl ::std::default::Default for PipelineColorBlendStateCreateInfo {
-    fn default() -> PipelineColorBlendStateCreateInfo {
-        PipelineColorBlendStateCreateInfo {
-            s_type: StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineColorBlendStateCreateFlags::default(),
             logic_op_enable: Bool32::default(),
@@ -5782,10 +6453,13 @@ impl ::std::default::Default for PipelineColorBlendStateCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineColorBlendStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+}
 impl PipelineColorBlendStateCreateInfo {
     pub fn builder<'a>() -> PipelineColorBlendStateCreateInfoBuilder<'a> {
         PipelineColorBlendStateCreateInfoBuilder {
-            inner: PipelineColorBlendStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5808,23 +6482,28 @@ impl<'a> ::std::ops::DerefMut for PipelineColorBlendStateCreateInfoBuilder<'a> {
     }
 }
 impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineColorBlendStateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self {
         self.inner.logic_op_enable = logic_op_enable.into();
         self
     }
+    #[inline]
     pub fn logic_op(mut self, logic_op: LogicOp) -> Self {
         self.inner.logic_op = logic_op;
         self
     }
+    #[inline]
     pub fn attachments(mut self, attachments: &'a [PipelineColorBlendAttachmentState]) -> Self {
         self.inner.attachment_count = attachments.len() as _;
         self.inner.p_attachments = attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn blend_constants(mut self, blend_constants: [f32; 4]) -> Self {
         self.inner.blend_constants = blend_constants;
         self
@@ -5839,10 +6518,10 @@ impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -5854,8 +6533,9 @@ impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDynamicStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDynamicStateCreateInfo.html>"]
 pub struct PipelineDynamicStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -5864,9 +6544,10 @@ pub struct PipelineDynamicStateCreateInfo {
     pub p_dynamic_states: *const DynamicState,
 }
 impl ::std::default::Default for PipelineDynamicStateCreateInfo {
-    fn default() -> PipelineDynamicStateCreateInfo {
-        PipelineDynamicStateCreateInfo {
-            s_type: StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineDynamicStateCreateFlags::default(),
             dynamic_state_count: u32::default(),
@@ -5874,10 +6555,13 @@ impl ::std::default::Default for PipelineDynamicStateCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineDynamicStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+}
 impl PipelineDynamicStateCreateInfo {
     pub fn builder<'a>() -> PipelineDynamicStateCreateInfoBuilder<'a> {
         PipelineDynamicStateCreateInfoBuilder {
-            inner: PipelineDynamicStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5899,10 +6583,12 @@ impl<'a> ::std::ops::DerefMut for PipelineDynamicStateCreateInfoBuilder<'a> {
     }
 }
 impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineDynamicStateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn dynamic_states(mut self, dynamic_states: &'a [DynamicState]) -> Self {
         self.inner.dynamic_state_count = dynamic_states.len() as _;
         self.inner.p_dynamic_states = dynamic_states.as_ptr();
@@ -5916,8 +6602,9 @@ impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilOpState.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilOpState.html>"]
 pub struct StencilOpState {
     pub fail_op: StencilOp,
     pub pass_op: StencilOp,
@@ -5930,7 +6617,7 @@ pub struct StencilOpState {
 impl StencilOpState {
     pub fn builder<'a>() -> StencilOpStateBuilder<'a> {
         StencilOpStateBuilder {
-            inner: StencilOpState::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -5952,30 +6639,37 @@ impl<'a> ::std::ops::DerefMut for StencilOpStateBuilder<'a> {
     }
 }
 impl<'a> StencilOpStateBuilder<'a> {
+    #[inline]
     pub fn fail_op(mut self, fail_op: StencilOp) -> Self {
         self.inner.fail_op = fail_op;
         self
     }
+    #[inline]
     pub fn pass_op(mut self, pass_op: StencilOp) -> Self {
         self.inner.pass_op = pass_op;
         self
     }
+    #[inline]
     pub fn depth_fail_op(mut self, depth_fail_op: StencilOp) -> Self {
         self.inner.depth_fail_op = depth_fail_op;
         self
     }
+    #[inline]
     pub fn compare_op(mut self, compare_op: CompareOp) -> Self {
         self.inner.compare_op = compare_op;
         self
     }
+    #[inline]
     pub fn compare_mask(mut self, compare_mask: u32) -> Self {
         self.inner.compare_mask = compare_mask;
         self
     }
+    #[inline]
     pub fn write_mask(mut self, write_mask: u32) -> Self {
         self.inner.write_mask = write_mask;
         self
     }
+    #[inline]
     pub fn reference(mut self, reference: u32) -> Self {
         self.inner.reference = reference;
         self
@@ -5988,8 +6682,9 @@ impl<'a> StencilOpStateBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDepthStencilStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDepthStencilStateCreateInfo.html>"]
 pub struct PipelineDepthStencilStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -6005,9 +6700,10 @@ pub struct PipelineDepthStencilStateCreateInfo {
     pub max_depth_bounds: f32,
 }
 impl ::std::default::Default for PipelineDepthStencilStateCreateInfo {
-    fn default() -> PipelineDepthStencilStateCreateInfo {
-        PipelineDepthStencilStateCreateInfo {
-            s_type: StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineDepthStencilStateCreateFlags::default(),
             depth_test_enable: Bool32::default(),
@@ -6022,10 +6718,13 @@ impl ::std::default::Default for PipelineDepthStencilStateCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineDepthStencilStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+}
 impl PipelineDepthStencilStateCreateInfo {
     pub fn builder<'a>() -> PipelineDepthStencilStateCreateInfoBuilder<'a> {
         PipelineDepthStencilStateCreateInfoBuilder {
-            inner: PipelineDepthStencilStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6047,42 +6746,52 @@ impl<'a> ::std::ops::DerefMut for PipelineDepthStencilStateCreateInfoBuilder<'a>
     }
 }
 impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineDepthStencilStateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self {
         self.inner.depth_test_enable = depth_test_enable.into();
         self
     }
+    #[inline]
     pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self {
         self.inner.depth_write_enable = depth_write_enable.into();
         self
     }
+    #[inline]
     pub fn depth_compare_op(mut self, depth_compare_op: CompareOp) -> Self {
         self.inner.depth_compare_op = depth_compare_op;
         self
     }
+    #[inline]
     pub fn depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self {
         self.inner.depth_bounds_test_enable = depth_bounds_test_enable.into();
         self
     }
+    #[inline]
     pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self {
         self.inner.stencil_test_enable = stencil_test_enable.into();
         self
     }
+    #[inline]
     pub fn front(mut self, front: StencilOpState) -> Self {
         self.inner.front = front;
         self
     }
+    #[inline]
     pub fn back(mut self, back: StencilOpState) -> Self {
         self.inner.back = back;
         self
     }
+    #[inline]
     pub fn min_depth_bounds(mut self, min_depth_bounds: f32) -> Self {
         self.inner.min_depth_bounds = min_depth_bounds;
         self
     }
+    #[inline]
     pub fn max_depth_bounds(mut self, max_depth_bounds: f32) -> Self {
         self.inner.max_depth_bounds = max_depth_bounds;
         self
@@ -6095,8 +6804,9 @@ impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsPipelineCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineCreateInfo.html>"]
 pub struct GraphicsPipelineCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -6119,9 +6829,10 @@ pub struct GraphicsPipelineCreateInfo {
     pub base_pipeline_index: i32,
 }
 impl ::std::default::Default for GraphicsPipelineCreateInfo {
-    fn default() -> GraphicsPipelineCreateInfo {
-        GraphicsPipelineCreateInfo {
-            s_type: StructureType::GRAPHICS_PIPELINE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineCreateFlags::default(),
             stage_count: u32::default(),
@@ -6143,10 +6854,13 @@ impl ::std::default::Default for GraphicsPipelineCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for GraphicsPipelineCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_CREATE_INFO;
+}
 impl GraphicsPipelineCreateInfo {
     pub fn builder<'a>() -> GraphicsPipelineCreateInfoBuilder<'a> {
         GraphicsPipelineCreateInfoBuilder {
-            inner: GraphicsPipelineCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6169,15 +6883,18 @@ impl<'a> ::std::ops::DerefMut for GraphicsPipelineCreateInfoBuilder<'a> {
     }
 }
 impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
         self.inner.stage_count = stages.len() as _;
         self.inner.p_stages = stages.as_ptr();
         self
     }
+    #[inline]
     pub fn vertex_input_state(
         mut self,
         vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
@@ -6185,6 +6902,7 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
         self.inner.p_vertex_input_state = vertex_input_state;
         self
     }
+    #[inline]
     pub fn input_assembly_state(
         mut self,
         input_assembly_state: &'a PipelineInputAssemblyStateCreateInfo,
@@ -6192,6 +6910,7 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
         self.inner.p_input_assembly_state = input_assembly_state;
         self
     }
+    #[inline]
     pub fn tessellation_state(
         mut self,
         tessellation_state: &'a PipelineTessellationStateCreateInfo,
@@ -6199,10 +6918,12 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
         self.inner.p_tessellation_state = tessellation_state;
         self
     }
+    #[inline]
     pub fn viewport_state(mut self, viewport_state: &'a PipelineViewportStateCreateInfo) -> Self {
         self.inner.p_viewport_state = viewport_state;
         self
     }
+    #[inline]
     pub fn rasterization_state(
         mut self,
         rasterization_state: &'a PipelineRasterizationStateCreateInfo,
@@ -6210,6 +6931,7 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
         self.inner.p_rasterization_state = rasterization_state;
         self
     }
+    #[inline]
     pub fn multisample_state(
         mut self,
         multisample_state: &'a PipelineMultisampleStateCreateInfo,
@@ -6217,6 +6939,7 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
         self.inner.p_multisample_state = multisample_state;
         self
     }
+    #[inline]
     pub fn depth_stencil_state(
         mut self,
         depth_stencil_state: &'a PipelineDepthStencilStateCreateInfo,
@@ -6224,6 +6947,7 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
         self.inner.p_depth_stencil_state = depth_stencil_state;
         self
     }
+    #[inline]
     pub fn color_blend_state(
         mut self,
         color_blend_state: &'a PipelineColorBlendStateCreateInfo,
@@ -6231,26 +6955,32 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
         self.inner.p_color_blend_state = color_blend_state;
         self
     }
+    #[inline]
     pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self {
         self.inner.p_dynamic_state = dynamic_state;
         self
     }
+    #[inline]
     pub fn layout(mut self, layout: PipelineLayout) -> Self {
         self.inner.layout = layout;
         self
     }
+    #[inline]
     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
         self.inner.render_pass = render_pass;
         self
     }
+    #[inline]
     pub fn subpass(mut self, subpass: u32) -> Self {
         self.inner.subpass = subpass;
         self
     }
+    #[inline]
     pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
         self.inner.base_pipeline_handle = base_pipeline_handle;
         self
     }
+    #[inline]
     pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
         self.inner.base_pipeline_index = base_pipeline_index;
         self
@@ -6262,10 +6992,10 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsGraphicsPipelineCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -6277,8 +7007,9 @@ impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheCreateInfo.html>"]
 pub struct PipelineCacheCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -6287,9 +7018,10 @@ pub struct PipelineCacheCreateInfo {
     pub p_initial_data: *const c_void,
 }
 impl ::std::default::Default for PipelineCacheCreateInfo {
-    fn default() -> PipelineCacheCreateInfo {
-        PipelineCacheCreateInfo {
-            s_type: StructureType::PIPELINE_CACHE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineCacheCreateFlags::default(),
             initial_data_size: usize::default(),
@@ -6297,10 +7029,13 @@ impl ::std::default::Default for PipelineCacheCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineCacheCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_CACHE_CREATE_INFO;
+}
 impl PipelineCacheCreateInfo {
     pub fn builder<'a>() -> PipelineCacheCreateInfoBuilder<'a> {
         PipelineCacheCreateInfoBuilder {
-            inner: PipelineCacheCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6322,13 +7057,15 @@ impl<'a> ::std::ops::DerefMut for PipelineCacheCreateInfoBuilder<'a> {
     }
 }
 impl<'a> PipelineCacheCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineCacheCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self {
-        self.inner.initial_data_size = initial_data.len() as _;
-        self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
+        self.inner.initial_data_size = initial_data.len();
+        self.inner.p_initial_data = initial_data.as_ptr().cast();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -6339,8 +7076,9 @@ impl<'a> PipelineCacheCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheHeaderVersionOne.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheHeaderVersionOne.html>"]
 pub struct PipelineCacheHeaderVersionOne {
     pub header_size: u32,
     pub header_version: PipelineCacheHeaderVersion,
@@ -6349,8 +7087,9 @@ pub struct PipelineCacheHeaderVersionOne {
     pub pipeline_cache_uuid: [u8; UUID_SIZE],
 }
 impl ::std::default::Default for PipelineCacheHeaderVersionOne {
-    fn default() -> PipelineCacheHeaderVersionOne {
-        PipelineCacheHeaderVersionOne {
+    #[inline]
+    fn default() -> Self {
+        Self {
             header_size: u32::default(),
             header_version: PipelineCacheHeaderVersion::default(),
             vendor_id: u32::default(),
@@ -6362,7 +7101,7 @@ impl ::std::default::Default for PipelineCacheHeaderVersionOne {
 impl PipelineCacheHeaderVersionOne {
     pub fn builder<'a>() -> PipelineCacheHeaderVersionOneBuilder<'a> {
         PipelineCacheHeaderVersionOneBuilder {
-            inner: PipelineCacheHeaderVersionOne::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6384,22 +7123,27 @@ impl<'a> ::std::ops::DerefMut for PipelineCacheHeaderVersionOneBuilder<'a> {
     }
 }
 impl<'a> PipelineCacheHeaderVersionOneBuilder<'a> {
+    #[inline]
     pub fn header_size(mut self, header_size: u32) -> Self {
         self.inner.header_size = header_size;
         self
     }
+    #[inline]
     pub fn header_version(mut self, header_version: PipelineCacheHeaderVersion) -> Self {
         self.inner.header_version = header_version;
         self
     }
+    #[inline]
     pub fn vendor_id(mut self, vendor_id: u32) -> Self {
         self.inner.vendor_id = vendor_id;
         self
     }
+    #[inline]
     pub fn device_id(mut self, device_id: u32) -> Self {
         self.inner.device_id = device_id;
         self
     }
+    #[inline]
     pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
         self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
         self
@@ -6412,8 +7156,9 @@ impl<'a> PipelineCacheHeaderVersionOneBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPushConstantRange.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPushConstantRange.html>"]
 pub struct PushConstantRange {
     pub stage_flags: ShaderStageFlags,
     pub offset: u32,
@@ -6422,7 +7167,7 @@ pub struct PushConstantRange {
 impl PushConstantRange {
     pub fn builder<'a>() -> PushConstantRangeBuilder<'a> {
         PushConstantRangeBuilder {
-            inner: PushConstantRange::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6444,14 +7189,17 @@ impl<'a> ::std::ops::DerefMut for PushConstantRangeBuilder<'a> {
     }
 }
 impl<'a> PushConstantRangeBuilder<'a> {
+    #[inline]
     pub fn stage_flags(mut self, stage_flags: ShaderStageFlags) -> Self {
         self.inner.stage_flags = stage_flags;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: u32) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: u32) -> Self {
         self.inner.size = size;
         self
@@ -6464,8 +7212,9 @@ impl<'a> PushConstantRangeBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLayoutCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLayoutCreateInfo.html>"]
 pub struct PipelineLayoutCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -6476,9 +7225,10 @@ pub struct PipelineLayoutCreateInfo {
     pub p_push_constant_ranges: *const PushConstantRange,
 }
 impl ::std::default::Default for PipelineLayoutCreateInfo {
-    fn default() -> PipelineLayoutCreateInfo {
-        PipelineLayoutCreateInfo {
-            s_type: StructureType::PIPELINE_LAYOUT_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineLayoutCreateFlags::default(),
             set_layout_count: u32::default(),
@@ -6488,10 +7238,13 @@ impl ::std::default::Default for PipelineLayoutCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineLayoutCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_LAYOUT_CREATE_INFO;
+}
 impl PipelineLayoutCreateInfo {
     pub fn builder<'a>() -> PipelineLayoutCreateInfoBuilder<'a> {
         PipelineLayoutCreateInfoBuilder {
-            inner: PipelineLayoutCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6513,15 +7266,18 @@ impl<'a> ::std::ops::DerefMut for PipelineLayoutCreateInfoBuilder<'a> {
     }
 }
 impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineLayoutCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
         self.inner.set_layout_count = set_layouts.len() as _;
         self.inner.p_set_layouts = set_layouts.as_ptr();
         self
     }
+    #[inline]
     pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self {
         self.inner.push_constant_range_count = push_constant_ranges.len() as _;
         self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr();
@@ -6535,8 +7291,9 @@ impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCreateInfo.html>"]
 pub struct SamplerCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -6558,9 +7315,10 @@ pub struct SamplerCreateInfo {
     pub unnormalized_coordinates: Bool32,
 }
 impl ::std::default::Default for SamplerCreateInfo {
-    fn default() -> SamplerCreateInfo {
-        SamplerCreateInfo {
-            s_type: StructureType::SAMPLER_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: SamplerCreateFlags::default(),
             mag_filter: Filter::default(),
@@ -6581,10 +7339,13 @@ impl ::std::default::Default for SamplerCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for SamplerCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CREATE_INFO;
+}
 impl SamplerCreateInfo {
     pub fn builder<'a>() -> SamplerCreateInfoBuilder<'a> {
         SamplerCreateInfoBuilder {
-            inner: SamplerCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6607,66 +7368,82 @@ impl<'a> ::std::ops::DerefMut for SamplerCreateInfoBuilder<'a> {
     }
 }
 impl<'a> SamplerCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: SamplerCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn mag_filter(mut self, mag_filter: Filter) -> Self {
         self.inner.mag_filter = mag_filter;
         self
     }
+    #[inline]
     pub fn min_filter(mut self, min_filter: Filter) -> Self {
         self.inner.min_filter = min_filter;
         self
     }
+    #[inline]
     pub fn mipmap_mode(mut self, mipmap_mode: SamplerMipmapMode) -> Self {
         self.inner.mipmap_mode = mipmap_mode;
         self
     }
+    #[inline]
     pub fn address_mode_u(mut self, address_mode_u: SamplerAddressMode) -> Self {
         self.inner.address_mode_u = address_mode_u;
         self
     }
+    #[inline]
     pub fn address_mode_v(mut self, address_mode_v: SamplerAddressMode) -> Self {
         self.inner.address_mode_v = address_mode_v;
         self
     }
+    #[inline]
     pub fn address_mode_w(mut self, address_mode_w: SamplerAddressMode) -> Self {
         self.inner.address_mode_w = address_mode_w;
         self
     }
+    #[inline]
     pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> Self {
         self.inner.mip_lod_bias = mip_lod_bias;
         self
     }
+    #[inline]
     pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self {
         self.inner.anisotropy_enable = anisotropy_enable.into();
         self
     }
+    #[inline]
     pub fn max_anisotropy(mut self, max_anisotropy: f32) -> Self {
         self.inner.max_anisotropy = max_anisotropy;
         self
     }
+    #[inline]
     pub fn compare_enable(mut self, compare_enable: bool) -> Self {
         self.inner.compare_enable = compare_enable.into();
         self
     }
+    #[inline]
     pub fn compare_op(mut self, compare_op: CompareOp) -> Self {
         self.inner.compare_op = compare_op;
         self
     }
+    #[inline]
     pub fn min_lod(mut self, min_lod: f32) -> Self {
         self.inner.min_lod = min_lod;
         self
     }
+    #[inline]
     pub fn max_lod(mut self, max_lod: f32) -> Self {
         self.inner.max_lod = max_lod;
         self
     }
+    #[inline]
     pub fn border_color(mut self, border_color: BorderColor) -> Self {
         self.inner.border_color = border_color;
         self
     }
+    #[inline]
     pub fn unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self {
         self.inner.unnormalized_coordinates = unnormalized_coordinates.into();
         self
@@ -6678,10 +7455,10 @@ impl<'a> SamplerCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsSamplerCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -6693,8 +7470,9 @@ impl<'a> SamplerCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandPoolCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandPoolCreateInfo.html>"]
 pub struct CommandPoolCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -6702,19 +7480,23 @@ pub struct CommandPoolCreateInfo {
     pub queue_family_index: u32,
 }
 impl ::std::default::Default for CommandPoolCreateInfo {
-    fn default() -> CommandPoolCreateInfo {
-        CommandPoolCreateInfo {
-            s_type: StructureType::COMMAND_POOL_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: CommandPoolCreateFlags::default(),
             queue_family_index: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for CommandPoolCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_POOL_CREATE_INFO;
+}
 impl CommandPoolCreateInfo {
     pub fn builder<'a>() -> CommandPoolCreateInfoBuilder<'a> {
         CommandPoolCreateInfoBuilder {
-            inner: CommandPoolCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6736,10 +7518,12 @@ impl<'a> ::std::ops::DerefMut for CommandPoolCreateInfoBuilder<'a> {
     }
 }
 impl<'a> CommandPoolCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: CommandPoolCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
         self.inner.queue_family_index = queue_family_index;
         self
@@ -6752,8 +7536,9 @@ impl<'a> CommandPoolCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferAllocateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferAllocateInfo.html>"]
 pub struct CommandBufferAllocateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -6762,9 +7547,10 @@ pub struct CommandBufferAllocateInfo {
     pub command_buffer_count: u32,
 }
 impl ::std::default::Default for CommandBufferAllocateInfo {
-    fn default() -> CommandBufferAllocateInfo {
-        CommandBufferAllocateInfo {
-            s_type: StructureType::COMMAND_BUFFER_ALLOCATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             command_pool: CommandPool::default(),
             level: CommandBufferLevel::default(),
@@ -6772,10 +7558,13 @@ impl ::std::default::Default for CommandBufferAllocateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for CommandBufferAllocateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_ALLOCATE_INFO;
+}
 impl CommandBufferAllocateInfo {
     pub fn builder<'a>() -> CommandBufferAllocateInfoBuilder<'a> {
         CommandBufferAllocateInfoBuilder {
-            inner: CommandBufferAllocateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6797,14 +7586,17 @@ impl<'a> ::std::ops::DerefMut for CommandBufferAllocateInfoBuilder<'a> {
     }
 }
 impl<'a> CommandBufferAllocateInfoBuilder<'a> {
+    #[inline]
     pub fn command_pool(mut self, command_pool: CommandPool) -> Self {
         self.inner.command_pool = command_pool;
         self
     }
+    #[inline]
     pub fn level(mut self, level: CommandBufferLevel) -> Self {
         self.inner.level = level;
         self
     }
+    #[inline]
     pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self {
         self.inner.command_buffer_count = command_buffer_count;
         self
@@ -6817,8 +7609,9 @@ impl<'a> CommandBufferAllocateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceInfo.html>"]
 pub struct CommandBufferInheritanceInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -6830,9 +7623,10 @@ pub struct CommandBufferInheritanceInfo {
     pub pipeline_statistics: QueryPipelineStatisticFlags,
 }
 impl ::std::default::Default for CommandBufferInheritanceInfo {
-    fn default() -> CommandBufferInheritanceInfo {
-        CommandBufferInheritanceInfo {
-            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             render_pass: RenderPass::default(),
             subpass: u32::default(),
@@ -6843,10 +7637,13 @@ impl ::std::default::Default for CommandBufferInheritanceInfo {
         }
     }
 }
+unsafe impl TaggedStructure for CommandBufferInheritanceInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_INFO;
+}
 impl CommandBufferInheritanceInfo {
     pub fn builder<'a>() -> CommandBufferInheritanceInfoBuilder<'a> {
         CommandBufferInheritanceInfoBuilder {
-            inner: CommandBufferInheritanceInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6869,26 +7666,32 @@ impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceInfoBuilder<'a> {
     }
 }
 impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
+    #[inline]
     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
         self.inner.render_pass = render_pass;
         self
     }
+    #[inline]
     pub fn subpass(mut self, subpass: u32) -> Self {
         self.inner.subpass = subpass;
         self
     }
+    #[inline]
     pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self {
         self.inner.framebuffer = framebuffer;
         self
     }
+    #[inline]
     pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self {
         self.inner.occlusion_query_enable = occlusion_query_enable.into();
         self
     }
+    #[inline]
     pub fn query_flags(mut self, query_flags: QueryControlFlags) -> Self {
         self.inner.query_flags = query_flags;
         self
     }
+    #[inline]
     pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self {
         self.inner.pipeline_statistics = pipeline_statistics;
         self
@@ -6900,10 +7703,10 @@ impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsCommandBufferInheritanceInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -6915,8 +7718,9 @@ impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferBeginInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferBeginInfo.html>"]
 pub struct CommandBufferBeginInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -6924,19 +7728,23 @@ pub struct CommandBufferBeginInfo {
     pub p_inheritance_info: *const CommandBufferInheritanceInfo,
 }
 impl ::std::default::Default for CommandBufferBeginInfo {
-    fn default() -> CommandBufferBeginInfo {
-        CommandBufferBeginInfo {
-            s_type: StructureType::COMMAND_BUFFER_BEGIN_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: CommandBufferUsageFlags::default(),
             p_inheritance_info: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for CommandBufferBeginInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_BEGIN_INFO;
+}
 impl CommandBufferBeginInfo {
     pub fn builder<'a>() -> CommandBufferBeginInfoBuilder<'a> {
         CommandBufferBeginInfoBuilder {
-            inner: CommandBufferBeginInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -6959,10 +7767,12 @@ impl<'a> ::std::ops::DerefMut for CommandBufferBeginInfoBuilder<'a> {
     }
 }
 impl<'a> CommandBufferBeginInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: CommandBufferUsageFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn inheritance_info(mut self, inheritance_info: &'a CommandBufferInheritanceInfo) -> Self {
         self.inner.p_inheritance_info = inheritance_info;
         self
@@ -6974,10 +7784,10 @@ impl<'a> CommandBufferBeginInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsCommandBufferBeginInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -6990,7 +7800,7 @@ impl<'a> CommandBufferBeginInfoBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassBeginInfo.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassBeginInfo.html>"]
 pub struct RenderPassBeginInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -7000,6 +7810,7 @@ pub struct RenderPassBeginInfo {
     pub clear_value_count: u32,
     pub p_clear_values: *const ClearValue,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for RenderPassBeginInfo {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("RenderPassBeginInfo")
@@ -7014,9 +7825,10 @@ impl fmt::Debug for RenderPassBeginInfo {
     }
 }
 impl ::std::default::Default for RenderPassBeginInfo {
-    fn default() -> RenderPassBeginInfo {
-        RenderPassBeginInfo {
-            s_type: StructureType::RENDER_PASS_BEGIN_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             render_pass: RenderPass::default(),
             framebuffer: Framebuffer::default(),
@@ -7026,10 +7838,13 @@ impl ::std::default::Default for RenderPassBeginInfo {
         }
     }
 }
+unsafe impl TaggedStructure for RenderPassBeginInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_BEGIN_INFO;
+}
 impl RenderPassBeginInfo {
     pub fn builder<'a>() -> RenderPassBeginInfoBuilder<'a> {
         RenderPassBeginInfoBuilder {
-            inner: RenderPassBeginInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7052,18 +7867,22 @@ impl<'a> ::std::ops::DerefMut for RenderPassBeginInfoBuilder<'a> {
     }
 }
 impl<'a> RenderPassBeginInfoBuilder<'a> {
+    #[inline]
     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
         self.inner.render_pass = render_pass;
         self
     }
+    #[inline]
     pub fn framebuffer(mut self, framebuffer: Framebuffer) -> Self {
         self.inner.framebuffer = framebuffer;
         self
     }
+    #[inline]
     pub fn render_area(mut self, render_area: Rect2D) -> Self {
         self.inner.render_area = render_area;
         self
     }
+    #[inline]
     pub fn clear_values(mut self, clear_values: &'a [ClearValue]) -> Self {
         self.inner.clear_value_count = clear_values.len() as _;
         self.inner.p_clear_values = clear_values.as_ptr();
@@ -7076,10 +7895,10 @@ impl<'a> RenderPassBeginInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsRenderPassBeginInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -7092,20 +7911,22 @@ impl<'a> RenderPassBeginInfoBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearColorValue.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearColorValue.html>"]
 pub union ClearColorValue {
     pub float32: [f32; 4],
     pub int32: [i32; 4],
     pub uint32: [u32; 4],
 }
 impl ::std::default::Default for ClearColorValue {
-    fn default() -> ClearColorValue {
+    #[inline]
+    fn default() -> Self {
         unsafe { ::std::mem::zeroed() }
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearDepthStencilValue.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearDepthStencilValue.html>"]
 pub struct ClearDepthStencilValue {
     pub depth: f32,
     pub stencil: u32,
@@ -7113,7 +7934,7 @@ pub struct ClearDepthStencilValue {
 impl ClearDepthStencilValue {
     pub fn builder<'a>() -> ClearDepthStencilValueBuilder<'a> {
         ClearDepthStencilValueBuilder {
-            inner: ClearDepthStencilValue::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7135,10 +7956,12 @@ impl<'a> ::std::ops::DerefMut for ClearDepthStencilValueBuilder<'a> {
     }
 }
 impl<'a> ClearDepthStencilValueBuilder<'a> {
+    #[inline]
     pub fn depth(mut self, depth: f32) -> Self {
         self.inner.depth = depth;
         self
     }
+    #[inline]
     pub fn stencil(mut self, stencil: u32) -> Self {
         self.inner.stencil = stencil;
         self
@@ -7152,24 +7975,26 @@ impl<'a> ClearDepthStencilValueBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearValue.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearValue.html>"]
 pub union ClearValue {
     pub color: ClearColorValue,
     pub depth_stencil: ClearDepthStencilValue,
 }
 impl ::std::default::Default for ClearValue {
-    fn default() -> ClearValue {
+    #[inline]
+    fn default() -> Self {
         unsafe { ::std::mem::zeroed() }
     }
 }
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkClearAttachment.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkClearAttachment.html>"]
 pub struct ClearAttachment {
     pub aspect_mask: ImageAspectFlags,
     pub color_attachment: u32,
     pub clear_value: ClearValue,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for ClearAttachment {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("ClearAttachment")
@@ -7182,7 +8007,7 @@ impl fmt::Debug for ClearAttachment {
 impl ClearAttachment {
     pub fn builder<'a>() -> ClearAttachmentBuilder<'a> {
         ClearAttachmentBuilder {
-            inner: ClearAttachment::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7204,14 +8029,17 @@ impl<'a> ::std::ops::DerefMut for ClearAttachmentBuilder<'a> {
     }
 }
 impl<'a> ClearAttachmentBuilder<'a> {
+    #[inline]
     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
         self.inner.aspect_mask = aspect_mask;
         self
     }
+    #[inline]
     pub fn color_attachment(mut self, color_attachment: u32) -> Self {
         self.inner.color_attachment = color_attachment;
         self
     }
+    #[inline]
     pub fn clear_value(mut self, clear_value: ClearValue) -> Self {
         self.inner.clear_value = clear_value;
         self
@@ -7224,8 +8052,9 @@ impl<'a> ClearAttachmentBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescription.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription.html>"]
 pub struct AttachmentDescription {
     pub flags: AttachmentDescriptionFlags,
     pub format: Format,
@@ -7240,7 +8069,7 @@ pub struct AttachmentDescription {
 impl AttachmentDescription {
     pub fn builder<'a>() -> AttachmentDescriptionBuilder<'a> {
         AttachmentDescriptionBuilder {
-            inner: AttachmentDescription::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7262,38 +8091,47 @@ impl<'a> ::std::ops::DerefMut for AttachmentDescriptionBuilder<'a> {
     }
 }
 impl<'a> AttachmentDescriptionBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn samples(mut self, samples: SampleCountFlags) -> Self {
         self.inner.samples = samples;
         self
     }
+    #[inline]
     pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
         self.inner.load_op = load_op;
         self
     }
+    #[inline]
     pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
         self.inner.store_op = store_op;
         self
     }
+    #[inline]
     pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self {
         self.inner.stencil_load_op = stencil_load_op;
         self
     }
+    #[inline]
     pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self {
         self.inner.stencil_store_op = stencil_store_op;
         self
     }
+    #[inline]
     pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
         self.inner.initial_layout = initial_layout;
         self
     }
+    #[inline]
     pub fn final_layout(mut self, final_layout: ImageLayout) -> Self {
         self.inner.final_layout = final_layout;
         self
@@ -7306,8 +8144,9 @@ impl<'a> AttachmentDescriptionBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentReference.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference.html>"]
 pub struct AttachmentReference {
     pub attachment: u32,
     pub layout: ImageLayout,
@@ -7315,7 +8154,7 @@ pub struct AttachmentReference {
 impl AttachmentReference {
     pub fn builder<'a>() -> AttachmentReferenceBuilder<'a> {
         AttachmentReferenceBuilder {
-            inner: AttachmentReference::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7337,10 +8176,12 @@ impl<'a> ::std::ops::DerefMut for AttachmentReferenceBuilder<'a> {
     }
 }
 impl<'a> AttachmentReferenceBuilder<'a> {
+    #[inline]
     pub fn attachment(mut self, attachment: u32) -> Self {
         self.inner.attachment = attachment;
         self
     }
+    #[inline]
     pub fn layout(mut self, layout: ImageLayout) -> Self {
         self.inner.layout = layout;
         self
@@ -7353,8 +8194,9 @@ impl<'a> AttachmentReferenceBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescription.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription.html>"]
 pub struct SubpassDescription {
     pub flags: SubpassDescriptionFlags,
     pub pipeline_bind_point: PipelineBindPoint,
@@ -7368,8 +8210,9 @@ pub struct SubpassDescription {
     pub p_preserve_attachments: *const u32,
 }
 impl ::std::default::Default for SubpassDescription {
-    fn default() -> SubpassDescription {
-        SubpassDescription {
+    #[inline]
+    fn default() -> Self {
+        Self {
             flags: SubpassDescriptionFlags::default(),
             pipeline_bind_point: PipelineBindPoint::default(),
             input_attachment_count: u32::default(),
@@ -7386,7 +8229,7 @@ impl ::std::default::Default for SubpassDescription {
 impl SubpassDescription {
     pub fn builder<'a>() -> SubpassDescriptionBuilder<'a> {
         SubpassDescriptionBuilder {
-            inner: SubpassDescription::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7408,29 +8251,35 @@ impl<'a> ::std::ops::DerefMut for SubpassDescriptionBuilder<'a> {
     }
 }
 impl<'a> SubpassDescriptionBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
         self.inner.pipeline_bind_point = pipeline_bind_point;
         self
     }
+    #[inline]
     pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference]) -> Self {
         self.inner.input_attachment_count = input_attachments.len() as _;
         self.inner.p_input_attachments = input_attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference]) -> Self {
         self.inner.color_attachment_count = color_attachments.len() as _;
         self.inner.p_color_attachments = color_attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference]) -> Self {
         self.inner.color_attachment_count = resolve_attachments.len() as _;
         self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn depth_stencil_attachment(
         mut self,
         depth_stencil_attachment: &'a AttachmentReference,
@@ -7438,6 +8287,7 @@ impl<'a> SubpassDescriptionBuilder<'a> {
         self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
         self
     }
+    #[inline]
     pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
         self.inner.preserve_attachment_count = preserve_attachments.len() as _;
         self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
@@ -7451,8 +8301,9 @@ impl<'a> SubpassDescriptionBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDependency.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency.html>"]
 pub struct SubpassDependency {
     pub src_subpass: u32,
     pub dst_subpass: u32,
@@ -7465,7 +8316,7 @@ pub struct SubpassDependency {
 impl SubpassDependency {
     pub fn builder<'a>() -> SubpassDependencyBuilder<'a> {
         SubpassDependencyBuilder {
-            inner: SubpassDependency::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7487,30 +8338,37 @@ impl<'a> ::std::ops::DerefMut for SubpassDependencyBuilder<'a> {
     }
 }
 impl<'a> SubpassDependencyBuilder<'a> {
+    #[inline]
     pub fn src_subpass(mut self, src_subpass: u32) -> Self {
         self.inner.src_subpass = src_subpass;
         self
     }
+    #[inline]
     pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
         self.inner.dst_subpass = dst_subpass;
         self
     }
+    #[inline]
     pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self {
         self.inner.src_stage_mask = src_stage_mask;
         self
     }
+    #[inline]
     pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self {
         self.inner.dst_stage_mask = dst_stage_mask;
         self
     }
+    #[inline]
     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
         self.inner.src_access_mask = src_access_mask;
         self
     }
+    #[inline]
     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
         self.inner.dst_access_mask = dst_access_mask;
         self
     }
+    #[inline]
     pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
         self.inner.dependency_flags = dependency_flags;
         self
@@ -7523,8 +8381,9 @@ impl<'a> SubpassDependencyBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo.html>"]
 pub struct RenderPassCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -7537,9 +8396,10 @@ pub struct RenderPassCreateInfo {
     pub p_dependencies: *const SubpassDependency,
 }
 impl ::std::default::Default for RenderPassCreateInfo {
-    fn default() -> RenderPassCreateInfo {
-        RenderPassCreateInfo {
-            s_type: StructureType::RENDER_PASS_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: RenderPassCreateFlags::default(),
             attachment_count: u32::default(),
@@ -7551,10 +8411,13 @@ impl ::std::default::Default for RenderPassCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for RenderPassCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATE_INFO;
+}
 impl RenderPassCreateInfo {
     pub fn builder<'a>() -> RenderPassCreateInfoBuilder<'a> {
         RenderPassCreateInfoBuilder {
-            inner: RenderPassCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7577,20 +8440,24 @@ impl<'a> ::std::ops::DerefMut for RenderPassCreateInfoBuilder<'a> {
     }
 }
 impl<'a> RenderPassCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn attachments(mut self, attachments: &'a [AttachmentDescription]) -> Self {
         self.inner.attachment_count = attachments.len() as _;
         self.inner.p_attachments = attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn subpasses(mut self, subpasses: &'a [SubpassDescription]) -> Self {
         self.inner.subpass_count = subpasses.len() as _;
         self.inner.p_subpasses = subpasses.as_ptr();
         self
     }
+    #[inline]
     pub fn dependencies(mut self, dependencies: &'a [SubpassDependency]) -> Self {
         self.inner.dependency_count = dependencies.len() as _;
         self.inner.p_dependencies = dependencies.as_ptr();
@@ -7603,10 +8470,10 @@ impl<'a> RenderPassCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsRenderPassCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -7618,26 +8485,31 @@ impl<'a> RenderPassCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkEventCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkEventCreateInfo.html>"]
 pub struct EventCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: EventCreateFlags,
 }
 impl ::std::default::Default for EventCreateInfo {
-    fn default() -> EventCreateInfo {
-        EventCreateInfo {
-            s_type: StructureType::EVENT_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: EventCreateFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for EventCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::EVENT_CREATE_INFO;
+}
 impl EventCreateInfo {
     pub fn builder<'a>() -> EventCreateInfoBuilder<'a> {
         EventCreateInfoBuilder {
-            inner: EventCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7647,6 +8519,7 @@ pub struct EventCreateInfoBuilder<'a> {
     inner: EventCreateInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+pub unsafe trait ExtendsEventCreateInfo {}
 impl<'a> ::std::ops::Deref for EventCreateInfoBuilder<'a> {
     type Target = EventCreateInfo;
     fn deref(&self) -> &Self::Target {
@@ -7659,10 +8532,25 @@ impl<'a> ::std::ops::DerefMut for EventCreateInfoBuilder<'a> {
     }
 }
 impl<'a> EventCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: EventCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsEventCreateInfo>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
@@ -7671,26 +8559,31 @@ impl<'a> EventCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceCreateInfo.html>"]
 pub struct FenceCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: FenceCreateFlags,
 }
 impl ::std::default::Default for FenceCreateInfo {
-    fn default() -> FenceCreateInfo {
-        FenceCreateInfo {
-            s_type: StructureType::FENCE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: FenceCreateFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for FenceCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::FENCE_CREATE_INFO;
+}
 impl FenceCreateInfo {
     pub fn builder<'a>() -> FenceCreateInfoBuilder<'a> {
         FenceCreateInfoBuilder {
-            inner: FenceCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7713,6 +8606,7 @@ impl<'a> ::std::ops::DerefMut for FenceCreateInfoBuilder<'a> {
     }
 }
 impl<'a> FenceCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: FenceCreateFlags) -> Self {
         self.inner.flags = flags;
         self
@@ -7724,10 +8618,10 @@ impl<'a> FenceCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsFenceCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -7739,8 +8633,9 @@ impl<'a> FenceCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures.html>"]
 pub struct PhysicalDeviceFeatures {
     pub robust_buffer_access: Bool32,
     pub full_draw_index_uint32: Bool32,
@@ -7801,7 +8696,7 @@ pub struct PhysicalDeviceFeatures {
 impl PhysicalDeviceFeatures {
     pub fn builder<'a>() -> PhysicalDeviceFeaturesBuilder<'a> {
         PhysicalDeviceFeaturesBuilder {
-            inner: PhysicalDeviceFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -7823,106 +8718,132 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeaturesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
+    #[inline]
     pub fn robust_buffer_access(mut self, robust_buffer_access: bool) -> Self {
         self.inner.robust_buffer_access = robust_buffer_access.into();
         self
     }
+    #[inline]
     pub fn full_draw_index_uint32(mut self, full_draw_index_uint32: bool) -> Self {
         self.inner.full_draw_index_uint32 = full_draw_index_uint32.into();
         self
     }
+    #[inline]
     pub fn image_cube_array(mut self, image_cube_array: bool) -> Self {
         self.inner.image_cube_array = image_cube_array.into();
         self
     }
+    #[inline]
     pub fn independent_blend(mut self, independent_blend: bool) -> Self {
         self.inner.independent_blend = independent_blend.into();
         self
     }
+    #[inline]
     pub fn geometry_shader(mut self, geometry_shader: bool) -> Self {
         self.inner.geometry_shader = geometry_shader.into();
         self
     }
+    #[inline]
     pub fn tessellation_shader(mut self, tessellation_shader: bool) -> Self {
         self.inner.tessellation_shader = tessellation_shader.into();
         self
     }
+    #[inline]
     pub fn sample_rate_shading(mut self, sample_rate_shading: bool) -> Self {
         self.inner.sample_rate_shading = sample_rate_shading.into();
         self
     }
+    #[inline]
     pub fn dual_src_blend(mut self, dual_src_blend: bool) -> Self {
         self.inner.dual_src_blend = dual_src_blend.into();
         self
     }
+    #[inline]
     pub fn logic_op(mut self, logic_op: bool) -> Self {
         self.inner.logic_op = logic_op.into();
         self
     }
+    #[inline]
     pub fn multi_draw_indirect(mut self, multi_draw_indirect: bool) -> Self {
         self.inner.multi_draw_indirect = multi_draw_indirect.into();
         self
     }
+    #[inline]
     pub fn draw_indirect_first_instance(mut self, draw_indirect_first_instance: bool) -> Self {
         self.inner.draw_indirect_first_instance = draw_indirect_first_instance.into();
         self
     }
+    #[inline]
     pub fn depth_clamp(mut self, depth_clamp: bool) -> Self {
         self.inner.depth_clamp = depth_clamp.into();
         self
     }
+    #[inline]
     pub fn depth_bias_clamp(mut self, depth_bias_clamp: bool) -> Self {
         self.inner.depth_bias_clamp = depth_bias_clamp.into();
         self
     }
+    #[inline]
     pub fn fill_mode_non_solid(mut self, fill_mode_non_solid: bool) -> Self {
         self.inner.fill_mode_non_solid = fill_mode_non_solid.into();
         self
     }
+    #[inline]
     pub fn depth_bounds(mut self, depth_bounds: bool) -> Self {
         self.inner.depth_bounds = depth_bounds.into();
         self
     }
+    #[inline]
     pub fn wide_lines(mut self, wide_lines: bool) -> Self {
         self.inner.wide_lines = wide_lines.into();
         self
     }
+    #[inline]
     pub fn large_points(mut self, large_points: bool) -> Self {
         self.inner.large_points = large_points.into();
         self
     }
+    #[inline]
     pub fn alpha_to_one(mut self, alpha_to_one: bool) -> Self {
         self.inner.alpha_to_one = alpha_to_one.into();
         self
     }
+    #[inline]
     pub fn multi_viewport(mut self, multi_viewport: bool) -> Self {
         self.inner.multi_viewport = multi_viewport.into();
         self
     }
+    #[inline]
     pub fn sampler_anisotropy(mut self, sampler_anisotropy: bool) -> Self {
         self.inner.sampler_anisotropy = sampler_anisotropy.into();
         self
     }
+    #[inline]
     pub fn texture_compression_etc2(mut self, texture_compression_etc2: bool) -> Self {
         self.inner.texture_compression_etc2 = texture_compression_etc2.into();
         self
     }
+    #[inline]
     pub fn texture_compression_astc_ldr(mut self, texture_compression_astc_ldr: bool) -> Self {
         self.inner.texture_compression_astc_ldr = texture_compression_astc_ldr.into();
         self
     }
+    #[inline]
     pub fn texture_compression_bc(mut self, texture_compression_bc: bool) -> Self {
         self.inner.texture_compression_bc = texture_compression_bc.into();
         self
     }
+    #[inline]
     pub fn occlusion_query_precise(mut self, occlusion_query_precise: bool) -> Self {
         self.inner.occlusion_query_precise = occlusion_query_precise.into();
         self
     }
+    #[inline]
     pub fn pipeline_statistics_query(mut self, pipeline_statistics_query: bool) -> Self {
         self.inner.pipeline_statistics_query = pipeline_statistics_query.into();
         self
     }
+    #[inline]
     pub fn vertex_pipeline_stores_and_atomics(
         mut self,
         vertex_pipeline_stores_and_atomics: bool,
@@ -7930,10 +8851,12 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
         self.inner.vertex_pipeline_stores_and_atomics = vertex_pipeline_stores_and_atomics.into();
         self
     }
+    #[inline]
     pub fn fragment_stores_and_atomics(mut self, fragment_stores_and_atomics: bool) -> Self {
         self.inner.fragment_stores_and_atomics = fragment_stores_and_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_tessellation_and_geometry_point_size(
         mut self,
         shader_tessellation_and_geometry_point_size: bool,
@@ -7942,10 +8865,12 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
             shader_tessellation_and_geometry_point_size.into();
         self
     }
+    #[inline]
     pub fn shader_image_gather_extended(mut self, shader_image_gather_extended: bool) -> Self {
         self.inner.shader_image_gather_extended = shader_image_gather_extended.into();
         self
     }
+    #[inline]
     pub fn shader_storage_image_extended_formats(
         mut self,
         shader_storage_image_extended_formats: bool,
@@ -7954,6 +8879,7 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
             shader_storage_image_extended_formats.into();
         self
     }
+    #[inline]
     pub fn shader_storage_image_multisample(
         mut self,
         shader_storage_image_multisample: bool,
@@ -7961,6 +8887,7 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
         self.inner.shader_storage_image_multisample = shader_storage_image_multisample.into();
         self
     }
+    #[inline]
     pub fn shader_storage_image_read_without_format(
         mut self,
         shader_storage_image_read_without_format: bool,
@@ -7969,6 +8896,7 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
             shader_storage_image_read_without_format.into();
         self
     }
+    #[inline]
     pub fn shader_storage_image_write_without_format(
         mut self,
         shader_storage_image_write_without_format: bool,
@@ -7977,6 +8905,7 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
             shader_storage_image_write_without_format.into();
         self
     }
+    #[inline]
     pub fn shader_uniform_buffer_array_dynamic_indexing(
         mut self,
         shader_uniform_buffer_array_dynamic_indexing: bool,
@@ -7985,6 +8914,7 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
             shader_uniform_buffer_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_sampled_image_array_dynamic_indexing(
         mut self,
         shader_sampled_image_array_dynamic_indexing: bool,
@@ -7993,6 +8923,7 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
             shader_sampled_image_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_buffer_array_dynamic_indexing(
         mut self,
         shader_storage_buffer_array_dynamic_indexing: bool,
@@ -8001,6 +8932,7 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
             shader_storage_buffer_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_image_array_dynamic_indexing(
         mut self,
         shader_storage_image_array_dynamic_indexing: bool,
@@ -8009,74 +8941,92 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
             shader_storage_image_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_clip_distance(mut self, shader_clip_distance: bool) -> Self {
         self.inner.shader_clip_distance = shader_clip_distance.into();
         self
     }
+    #[inline]
     pub fn shader_cull_distance(mut self, shader_cull_distance: bool) -> Self {
         self.inner.shader_cull_distance = shader_cull_distance.into();
         self
     }
+    #[inline]
     pub fn shader_float64(mut self, shader_float64: bool) -> Self {
         self.inner.shader_float64 = shader_float64.into();
         self
     }
+    #[inline]
     pub fn shader_int64(mut self, shader_int64: bool) -> Self {
         self.inner.shader_int64 = shader_int64.into();
         self
     }
+    #[inline]
     pub fn shader_int16(mut self, shader_int16: bool) -> Self {
         self.inner.shader_int16 = shader_int16.into();
         self
     }
+    #[inline]
     pub fn shader_resource_residency(mut self, shader_resource_residency: bool) -> Self {
         self.inner.shader_resource_residency = shader_resource_residency.into();
         self
     }
+    #[inline]
     pub fn shader_resource_min_lod(mut self, shader_resource_min_lod: bool) -> Self {
         self.inner.shader_resource_min_lod = shader_resource_min_lod.into();
         self
     }
+    #[inline]
     pub fn sparse_binding(mut self, sparse_binding: bool) -> Self {
         self.inner.sparse_binding = sparse_binding.into();
         self
     }
+    #[inline]
     pub fn sparse_residency_buffer(mut self, sparse_residency_buffer: bool) -> Self {
         self.inner.sparse_residency_buffer = sparse_residency_buffer.into();
         self
     }
+    #[inline]
     pub fn sparse_residency_image2_d(mut self, sparse_residency_image2_d: bool) -> Self {
         self.inner.sparse_residency_image2_d = sparse_residency_image2_d.into();
         self
     }
+    #[inline]
     pub fn sparse_residency_image3_d(mut self, sparse_residency_image3_d: bool) -> Self {
         self.inner.sparse_residency_image3_d = sparse_residency_image3_d.into();
         self
     }
+    #[inline]
     pub fn sparse_residency2_samples(mut self, sparse_residency2_samples: bool) -> Self {
         self.inner.sparse_residency2_samples = sparse_residency2_samples.into();
         self
     }
+    #[inline]
     pub fn sparse_residency4_samples(mut self, sparse_residency4_samples: bool) -> Self {
         self.inner.sparse_residency4_samples = sparse_residency4_samples.into();
         self
     }
+    #[inline]
     pub fn sparse_residency8_samples(mut self, sparse_residency8_samples: bool) -> Self {
         self.inner.sparse_residency8_samples = sparse_residency8_samples.into();
         self
     }
+    #[inline]
     pub fn sparse_residency16_samples(mut self, sparse_residency16_samples: bool) -> Self {
         self.inner.sparse_residency16_samples = sparse_residency16_samples.into();
         self
     }
+    #[inline]
     pub fn sparse_residency_aliased(mut self, sparse_residency_aliased: bool) -> Self {
         self.inner.sparse_residency_aliased = sparse_residency_aliased.into();
         self
     }
+    #[inline]
     pub fn variable_multisample_rate(mut self, variable_multisample_rate: bool) -> Self {
         self.inner.variable_multisample_rate = variable_multisample_rate.into();
         self
     }
+    #[inline]
     pub fn inherited_queries(mut self, inherited_queries: bool) -> Self {
         self.inner.inherited_queries = inherited_queries.into();
         self
@@ -8089,8 +9039,9 @@ impl<'a> PhysicalDeviceFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseProperties.html>"]
 pub struct PhysicalDeviceSparseProperties {
     pub residency_standard2_d_block_shape: Bool32,
     pub residency_standard2_d_multisample_block_shape: Bool32,
@@ -8101,7 +9052,7 @@ pub struct PhysicalDeviceSparseProperties {
 impl PhysicalDeviceSparseProperties {
     pub fn builder<'a>() -> PhysicalDeviceSparsePropertiesBuilder<'a> {
         PhysicalDeviceSparsePropertiesBuilder {
-            inner: PhysicalDeviceSparseProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -8123,6 +9074,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparsePropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
+    #[inline]
     pub fn residency_standard2_d_block_shape(
         mut self,
         residency_standard2_d_block_shape: bool,
@@ -8130,6 +9082,7 @@ impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
         self.inner.residency_standard2_d_block_shape = residency_standard2_d_block_shape.into();
         self
     }
+    #[inline]
     pub fn residency_standard2_d_multisample_block_shape(
         mut self,
         residency_standard2_d_multisample_block_shape: bool,
@@ -8138,6 +9091,7 @@ impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
             residency_standard2_d_multisample_block_shape.into();
         self
     }
+    #[inline]
     pub fn residency_standard3_d_block_shape(
         mut self,
         residency_standard3_d_block_shape: bool,
@@ -8145,10 +9099,12 @@ impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
         self.inner.residency_standard3_d_block_shape = residency_standard3_d_block_shape.into();
         self
     }
+    #[inline]
     pub fn residency_aligned_mip_size(mut self, residency_aligned_mip_size: bool) -> Self {
         self.inner.residency_aligned_mip_size = residency_aligned_mip_size.into();
         self
     }
+    #[inline]
     pub fn residency_non_resident_strict(mut self, residency_non_resident_strict: bool) -> Self {
         self.inner.residency_non_resident_strict = residency_non_resident_strict.into();
         self
@@ -8161,8 +9117,9 @@ impl<'a> PhysicalDeviceSparsePropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLimits.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLimits.html>"]
 pub struct PhysicalDeviceLimits {
     pub max_image_dimension1_d: u32,
     pub max_image_dimension2_d: u32,
@@ -8272,8 +9229,9 @@ pub struct PhysicalDeviceLimits {
     pub non_coherent_atom_size: DeviceSize,
 }
 impl ::std::default::Default for PhysicalDeviceLimits {
-    fn default() -> PhysicalDeviceLimits {
-        PhysicalDeviceLimits {
+    #[inline]
+    fn default() -> Self {
+        Self {
             max_image_dimension1_d: u32::default(),
             max_image_dimension2_d: u32::default(),
             max_image_dimension3_d: u32::default(),
@@ -8386,7 +9344,7 @@ impl ::std::default::Default for PhysicalDeviceLimits {
 impl PhysicalDeviceLimits {
     pub fn builder<'a>() -> PhysicalDeviceLimitsBuilder<'a> {
         PhysicalDeviceLimitsBuilder {
-            inner: PhysicalDeviceLimits::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -8408,62 +9366,77 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceLimitsBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceLimitsBuilder<'a> {
+    #[inline]
     pub fn max_image_dimension1_d(mut self, max_image_dimension1_d: u32) -> Self {
         self.inner.max_image_dimension1_d = max_image_dimension1_d;
         self
     }
+    #[inline]
     pub fn max_image_dimension2_d(mut self, max_image_dimension2_d: u32) -> Self {
         self.inner.max_image_dimension2_d = max_image_dimension2_d;
         self
     }
+    #[inline]
     pub fn max_image_dimension3_d(mut self, max_image_dimension3_d: u32) -> Self {
         self.inner.max_image_dimension3_d = max_image_dimension3_d;
         self
     }
+    #[inline]
     pub fn max_image_dimension_cube(mut self, max_image_dimension_cube: u32) -> Self {
         self.inner.max_image_dimension_cube = max_image_dimension_cube;
         self
     }
+    #[inline]
     pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
         self.inner.max_image_array_layers = max_image_array_layers;
         self
     }
+    #[inline]
     pub fn max_texel_buffer_elements(mut self, max_texel_buffer_elements: u32) -> Self {
         self.inner.max_texel_buffer_elements = max_texel_buffer_elements;
         self
     }
+    #[inline]
     pub fn max_uniform_buffer_range(mut self, max_uniform_buffer_range: u32) -> Self {
         self.inner.max_uniform_buffer_range = max_uniform_buffer_range;
         self
     }
+    #[inline]
     pub fn max_storage_buffer_range(mut self, max_storage_buffer_range: u32) -> Self {
         self.inner.max_storage_buffer_range = max_storage_buffer_range;
         self
     }
+    #[inline]
     pub fn max_push_constants_size(mut self, max_push_constants_size: u32) -> Self {
         self.inner.max_push_constants_size = max_push_constants_size;
         self
     }
+    #[inline]
     pub fn max_memory_allocation_count(mut self, max_memory_allocation_count: u32) -> Self {
         self.inner.max_memory_allocation_count = max_memory_allocation_count;
         self
     }
+    #[inline]
     pub fn max_sampler_allocation_count(mut self, max_sampler_allocation_count: u32) -> Self {
         self.inner.max_sampler_allocation_count = max_sampler_allocation_count;
         self
     }
+    #[inline]
     pub fn buffer_image_granularity(mut self, buffer_image_granularity: DeviceSize) -> Self {
         self.inner.buffer_image_granularity = buffer_image_granularity;
         self
     }
+    #[inline]
     pub fn sparse_address_space_size(mut self, sparse_address_space_size: DeviceSize) -> Self {
         self.inner.sparse_address_space_size = sparse_address_space_size;
         self
     }
+    #[inline]
     pub fn max_bound_descriptor_sets(mut self, max_bound_descriptor_sets: u32) -> Self {
         self.inner.max_bound_descriptor_sets = max_bound_descriptor_sets;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_samplers(
         mut self,
         max_per_stage_descriptor_samplers: u32,
@@ -8471,6 +9444,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_per_stage_descriptor_samplers = max_per_stage_descriptor_samplers;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_uniform_buffers(
         mut self,
         max_per_stage_descriptor_uniform_buffers: u32,
@@ -8479,6 +9453,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_per_stage_descriptor_uniform_buffers;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_storage_buffers(
         mut self,
         max_per_stage_descriptor_storage_buffers: u32,
@@ -8487,6 +9462,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_per_stage_descriptor_storage_buffers;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_sampled_images(
         mut self,
         max_per_stage_descriptor_sampled_images: u32,
@@ -8495,6 +9471,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_per_stage_descriptor_sampled_images;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_storage_images(
         mut self,
         max_per_stage_descriptor_storage_images: u32,
@@ -8503,6 +9480,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_per_stage_descriptor_storage_images;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_input_attachments(
         mut self,
         max_per_stage_descriptor_input_attachments: u32,
@@ -8511,14 +9489,17 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_per_stage_descriptor_input_attachments;
         self
     }
+    #[inline]
     pub fn max_per_stage_resources(mut self, max_per_stage_resources: u32) -> Self {
         self.inner.max_per_stage_resources = max_per_stage_resources;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_samplers(mut self, max_descriptor_set_samplers: u32) -> Self {
         self.inner.max_descriptor_set_samplers = max_descriptor_set_samplers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_uniform_buffers(
         mut self,
         max_descriptor_set_uniform_buffers: u32,
@@ -8526,6 +9507,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_descriptor_set_uniform_buffers = max_descriptor_set_uniform_buffers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_uniform_buffers_dynamic(
         mut self,
         max_descriptor_set_uniform_buffers_dynamic: u32,
@@ -8534,6 +9516,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_descriptor_set_uniform_buffers_dynamic;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_storage_buffers(
         mut self,
         max_descriptor_set_storage_buffers: u32,
@@ -8541,6 +9524,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_descriptor_set_storage_buffers = max_descriptor_set_storage_buffers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_storage_buffers_dynamic(
         mut self,
         max_descriptor_set_storage_buffers_dynamic: u32,
@@ -8549,6 +9533,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_descriptor_set_storage_buffers_dynamic;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_sampled_images(
         mut self,
         max_descriptor_set_sampled_images: u32,
@@ -8556,6 +9541,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_descriptor_set_sampled_images = max_descriptor_set_sampled_images;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_storage_images(
         mut self,
         max_descriptor_set_storage_images: u32,
@@ -8563,6 +9549,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_descriptor_set_storage_images = max_descriptor_set_storage_images;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_input_attachments(
         mut self,
         max_descriptor_set_input_attachments: u32,
@@ -8570,14 +9557,17 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_descriptor_set_input_attachments = max_descriptor_set_input_attachments;
         self
     }
+    #[inline]
     pub fn max_vertex_input_attributes(mut self, max_vertex_input_attributes: u32) -> Self {
         self.inner.max_vertex_input_attributes = max_vertex_input_attributes;
         self
     }
+    #[inline]
     pub fn max_vertex_input_bindings(mut self, max_vertex_input_bindings: u32) -> Self {
         self.inner.max_vertex_input_bindings = max_vertex_input_bindings;
         self
     }
+    #[inline]
     pub fn max_vertex_input_attribute_offset(
         mut self,
         max_vertex_input_attribute_offset: u32,
@@ -8585,14 +9575,17 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_vertex_input_attribute_offset = max_vertex_input_attribute_offset;
         self
     }
+    #[inline]
     pub fn max_vertex_input_binding_stride(mut self, max_vertex_input_binding_stride: u32) -> Self {
         self.inner.max_vertex_input_binding_stride = max_vertex_input_binding_stride;
         self
     }
+    #[inline]
     pub fn max_vertex_output_components(mut self, max_vertex_output_components: u32) -> Self {
         self.inner.max_vertex_output_components = max_vertex_output_components;
         self
     }
+    #[inline]
     pub fn max_tessellation_generation_level(
         mut self,
         max_tessellation_generation_level: u32,
@@ -8600,10 +9593,12 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_tessellation_generation_level = max_tessellation_generation_level;
         self
     }
+    #[inline]
     pub fn max_tessellation_patch_size(mut self, max_tessellation_patch_size: u32) -> Self {
         self.inner.max_tessellation_patch_size = max_tessellation_patch_size;
         self
     }
+    #[inline]
     pub fn max_tessellation_control_per_vertex_input_components(
         mut self,
         max_tessellation_control_per_vertex_input_components: u32,
@@ -8613,6 +9608,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_tessellation_control_per_vertex_input_components;
         self
     }
+    #[inline]
     pub fn max_tessellation_control_per_vertex_output_components(
         mut self,
         max_tessellation_control_per_vertex_output_components: u32,
@@ -8622,6 +9618,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_tessellation_control_per_vertex_output_components;
         self
     }
+    #[inline]
     pub fn max_tessellation_control_per_patch_output_components(
         mut self,
         max_tessellation_control_per_patch_output_components: u32,
@@ -8631,6 +9628,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_tessellation_control_per_patch_output_components;
         self
     }
+    #[inline]
     pub fn max_tessellation_control_total_output_components(
         mut self,
         max_tessellation_control_total_output_components: u32,
@@ -8639,6 +9637,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_tessellation_control_total_output_components;
         self
     }
+    #[inline]
     pub fn max_tessellation_evaluation_input_components(
         mut self,
         max_tessellation_evaluation_input_components: u32,
@@ -8647,6 +9646,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_tessellation_evaluation_input_components;
         self
     }
+    #[inline]
     pub fn max_tessellation_evaluation_output_components(
         mut self,
         max_tessellation_evaluation_output_components: u32,
@@ -8655,22 +9655,27 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             max_tessellation_evaluation_output_components;
         self
     }
+    #[inline]
     pub fn max_geometry_shader_invocations(mut self, max_geometry_shader_invocations: u32) -> Self {
         self.inner.max_geometry_shader_invocations = max_geometry_shader_invocations;
         self
     }
+    #[inline]
     pub fn max_geometry_input_components(mut self, max_geometry_input_components: u32) -> Self {
         self.inner.max_geometry_input_components = max_geometry_input_components;
         self
     }
+    #[inline]
     pub fn max_geometry_output_components(mut self, max_geometry_output_components: u32) -> Self {
         self.inner.max_geometry_output_components = max_geometry_output_components;
         self
     }
+    #[inline]
     pub fn max_geometry_output_vertices(mut self, max_geometry_output_vertices: u32) -> Self {
         self.inner.max_geometry_output_vertices = max_geometry_output_vertices;
         self
     }
+    #[inline]
     pub fn max_geometry_total_output_components(
         mut self,
         max_geometry_total_output_components: u32,
@@ -8678,14 +9683,17 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_geometry_total_output_components = max_geometry_total_output_components;
         self
     }
+    #[inline]
     pub fn max_fragment_input_components(mut self, max_fragment_input_components: u32) -> Self {
         self.inner.max_fragment_input_components = max_fragment_input_components;
         self
     }
+    #[inline]
     pub fn max_fragment_output_attachments(mut self, max_fragment_output_attachments: u32) -> Self {
         self.inner.max_fragment_output_attachments = max_fragment_output_attachments;
         self
     }
+    #[inline]
     pub fn max_fragment_dual_src_attachments(
         mut self,
         max_fragment_dual_src_attachments: u32,
@@ -8693,6 +9701,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_fragment_dual_src_attachments = max_fragment_dual_src_attachments;
         self
     }
+    #[inline]
     pub fn max_fragment_combined_output_resources(
         mut self,
         max_fragment_combined_output_resources: u32,
@@ -8700,14 +9709,17 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_fragment_combined_output_resources = max_fragment_combined_output_resources;
         self
     }
+    #[inline]
     pub fn max_compute_shared_memory_size(mut self, max_compute_shared_memory_size: u32) -> Self {
         self.inner.max_compute_shared_memory_size = max_compute_shared_memory_size;
         self
     }
+    #[inline]
     pub fn max_compute_work_group_count(mut self, max_compute_work_group_count: [u32; 3]) -> Self {
         self.inner.max_compute_work_group_count = max_compute_work_group_count;
         self
     }
+    #[inline]
     pub fn max_compute_work_group_invocations(
         mut self,
         max_compute_work_group_invocations: u32,
@@ -8715,58 +9727,72 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_compute_work_group_invocations = max_compute_work_group_invocations;
         self
     }
+    #[inline]
     pub fn max_compute_work_group_size(mut self, max_compute_work_group_size: [u32; 3]) -> Self {
         self.inner.max_compute_work_group_size = max_compute_work_group_size;
         self
     }
+    #[inline]
     pub fn sub_pixel_precision_bits(mut self, sub_pixel_precision_bits: u32) -> Self {
         self.inner.sub_pixel_precision_bits = sub_pixel_precision_bits;
         self
     }
+    #[inline]
     pub fn sub_texel_precision_bits(mut self, sub_texel_precision_bits: u32) -> Self {
         self.inner.sub_texel_precision_bits = sub_texel_precision_bits;
         self
     }
+    #[inline]
     pub fn mipmap_precision_bits(mut self, mipmap_precision_bits: u32) -> Self {
         self.inner.mipmap_precision_bits = mipmap_precision_bits;
         self
     }
+    #[inline]
     pub fn max_draw_indexed_index_value(mut self, max_draw_indexed_index_value: u32) -> Self {
         self.inner.max_draw_indexed_index_value = max_draw_indexed_index_value;
         self
     }
+    #[inline]
     pub fn max_draw_indirect_count(mut self, max_draw_indirect_count: u32) -> Self {
         self.inner.max_draw_indirect_count = max_draw_indirect_count;
         self
     }
+    #[inline]
     pub fn max_sampler_lod_bias(mut self, max_sampler_lod_bias: f32) -> Self {
         self.inner.max_sampler_lod_bias = max_sampler_lod_bias;
         self
     }
+    #[inline]
     pub fn max_sampler_anisotropy(mut self, max_sampler_anisotropy: f32) -> Self {
         self.inner.max_sampler_anisotropy = max_sampler_anisotropy;
         self
     }
+    #[inline]
     pub fn max_viewports(mut self, max_viewports: u32) -> Self {
         self.inner.max_viewports = max_viewports;
         self
     }
+    #[inline]
     pub fn max_viewport_dimensions(mut self, max_viewport_dimensions: [u32; 2]) -> Self {
         self.inner.max_viewport_dimensions = max_viewport_dimensions;
         self
     }
+    #[inline]
     pub fn viewport_bounds_range(mut self, viewport_bounds_range: [f32; 2]) -> Self {
         self.inner.viewport_bounds_range = viewport_bounds_range;
         self
     }
+    #[inline]
     pub fn viewport_sub_pixel_bits(mut self, viewport_sub_pixel_bits: u32) -> Self {
         self.inner.viewport_sub_pixel_bits = viewport_sub_pixel_bits;
         self
     }
+    #[inline]
     pub fn min_memory_map_alignment(mut self, min_memory_map_alignment: usize) -> Self {
         self.inner.min_memory_map_alignment = min_memory_map_alignment;
         self
     }
+    #[inline]
     pub fn min_texel_buffer_offset_alignment(
         mut self,
         min_texel_buffer_offset_alignment: DeviceSize,
@@ -8774,6 +9800,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.min_texel_buffer_offset_alignment = min_texel_buffer_offset_alignment;
         self
     }
+    #[inline]
     pub fn min_uniform_buffer_offset_alignment(
         mut self,
         min_uniform_buffer_offset_alignment: DeviceSize,
@@ -8781,6 +9808,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.min_uniform_buffer_offset_alignment = min_uniform_buffer_offset_alignment;
         self
     }
+    #[inline]
     pub fn min_storage_buffer_offset_alignment(
         mut self,
         min_storage_buffer_offset_alignment: DeviceSize,
@@ -8788,30 +9816,37 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.min_storage_buffer_offset_alignment = min_storage_buffer_offset_alignment;
         self
     }
+    #[inline]
     pub fn min_texel_offset(mut self, min_texel_offset: i32) -> Self {
         self.inner.min_texel_offset = min_texel_offset;
         self
     }
+    #[inline]
     pub fn max_texel_offset(mut self, max_texel_offset: u32) -> Self {
         self.inner.max_texel_offset = max_texel_offset;
         self
     }
+    #[inline]
     pub fn min_texel_gather_offset(mut self, min_texel_gather_offset: i32) -> Self {
         self.inner.min_texel_gather_offset = min_texel_gather_offset;
         self
     }
+    #[inline]
     pub fn max_texel_gather_offset(mut self, max_texel_gather_offset: u32) -> Self {
         self.inner.max_texel_gather_offset = max_texel_gather_offset;
         self
     }
+    #[inline]
     pub fn min_interpolation_offset(mut self, min_interpolation_offset: f32) -> Self {
         self.inner.min_interpolation_offset = min_interpolation_offset;
         self
     }
+    #[inline]
     pub fn max_interpolation_offset(mut self, max_interpolation_offset: f32) -> Self {
         self.inner.max_interpolation_offset = max_interpolation_offset;
         self
     }
+    #[inline]
     pub fn sub_pixel_interpolation_offset_bits(
         mut self,
         sub_pixel_interpolation_offset_bits: u32,
@@ -8819,18 +9854,22 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.sub_pixel_interpolation_offset_bits = sub_pixel_interpolation_offset_bits;
         self
     }
+    #[inline]
     pub fn max_framebuffer_width(mut self, max_framebuffer_width: u32) -> Self {
         self.inner.max_framebuffer_width = max_framebuffer_width;
         self
     }
+    #[inline]
     pub fn max_framebuffer_height(mut self, max_framebuffer_height: u32) -> Self {
         self.inner.max_framebuffer_height = max_framebuffer_height;
         self
     }
+    #[inline]
     pub fn max_framebuffer_layers(mut self, max_framebuffer_layers: u32) -> Self {
         self.inner.max_framebuffer_layers = max_framebuffer_layers;
         self
     }
+    #[inline]
     pub fn framebuffer_color_sample_counts(
         mut self,
         framebuffer_color_sample_counts: SampleCountFlags,
@@ -8838,6 +9877,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.framebuffer_color_sample_counts = framebuffer_color_sample_counts;
         self
     }
+    #[inline]
     pub fn framebuffer_depth_sample_counts(
         mut self,
         framebuffer_depth_sample_counts: SampleCountFlags,
@@ -8845,6 +9885,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.framebuffer_depth_sample_counts = framebuffer_depth_sample_counts;
         self
     }
+    #[inline]
     pub fn framebuffer_stencil_sample_counts(
         mut self,
         framebuffer_stencil_sample_counts: SampleCountFlags,
@@ -8852,6 +9893,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.framebuffer_stencil_sample_counts = framebuffer_stencil_sample_counts;
         self
     }
+    #[inline]
     pub fn framebuffer_no_attachments_sample_counts(
         mut self,
         framebuffer_no_attachments_sample_counts: SampleCountFlags,
@@ -8860,10 +9902,12 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             framebuffer_no_attachments_sample_counts;
         self
     }
+    #[inline]
     pub fn max_color_attachments(mut self, max_color_attachments: u32) -> Self {
         self.inner.max_color_attachments = max_color_attachments;
         self
     }
+    #[inline]
     pub fn sampled_image_color_sample_counts(
         mut self,
         sampled_image_color_sample_counts: SampleCountFlags,
@@ -8871,6 +9915,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.sampled_image_color_sample_counts = sampled_image_color_sample_counts;
         self
     }
+    #[inline]
     pub fn sampled_image_integer_sample_counts(
         mut self,
         sampled_image_integer_sample_counts: SampleCountFlags,
@@ -8878,6 +9923,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.sampled_image_integer_sample_counts = sampled_image_integer_sample_counts;
         self
     }
+    #[inline]
     pub fn sampled_image_depth_sample_counts(
         mut self,
         sampled_image_depth_sample_counts: SampleCountFlags,
@@ -8885,6 +9931,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.sampled_image_depth_sample_counts = sampled_image_depth_sample_counts;
         self
     }
+    #[inline]
     pub fn sampled_image_stencil_sample_counts(
         mut self,
         sampled_image_stencil_sample_counts: SampleCountFlags,
@@ -8892,6 +9939,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.sampled_image_stencil_sample_counts = sampled_image_stencil_sample_counts;
         self
     }
+    #[inline]
     pub fn storage_image_sample_counts(
         mut self,
         storage_image_sample_counts: SampleCountFlags,
@@ -8899,26 +9947,32 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.storage_image_sample_counts = storage_image_sample_counts;
         self
     }
+    #[inline]
     pub fn max_sample_mask_words(mut self, max_sample_mask_words: u32) -> Self {
         self.inner.max_sample_mask_words = max_sample_mask_words;
         self
     }
+    #[inline]
     pub fn timestamp_compute_and_graphics(mut self, timestamp_compute_and_graphics: bool) -> Self {
         self.inner.timestamp_compute_and_graphics = timestamp_compute_and_graphics.into();
         self
     }
+    #[inline]
     pub fn timestamp_period(mut self, timestamp_period: f32) -> Self {
         self.inner.timestamp_period = timestamp_period;
         self
     }
+    #[inline]
     pub fn max_clip_distances(mut self, max_clip_distances: u32) -> Self {
         self.inner.max_clip_distances = max_clip_distances;
         self
     }
+    #[inline]
     pub fn max_cull_distances(mut self, max_cull_distances: u32) -> Self {
         self.inner.max_cull_distances = max_cull_distances;
         self
     }
+    #[inline]
     pub fn max_combined_clip_and_cull_distances(
         mut self,
         max_combined_clip_and_cull_distances: u32,
@@ -8926,34 +9980,42 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.max_combined_clip_and_cull_distances = max_combined_clip_and_cull_distances;
         self
     }
+    #[inline]
     pub fn discrete_queue_priorities(mut self, discrete_queue_priorities: u32) -> Self {
         self.inner.discrete_queue_priorities = discrete_queue_priorities;
         self
     }
+    #[inline]
     pub fn point_size_range(mut self, point_size_range: [f32; 2]) -> Self {
         self.inner.point_size_range = point_size_range;
         self
     }
+    #[inline]
     pub fn line_width_range(mut self, line_width_range: [f32; 2]) -> Self {
         self.inner.line_width_range = line_width_range;
         self
     }
+    #[inline]
     pub fn point_size_granularity(mut self, point_size_granularity: f32) -> Self {
         self.inner.point_size_granularity = point_size_granularity;
         self
     }
+    #[inline]
     pub fn line_width_granularity(mut self, line_width_granularity: f32) -> Self {
         self.inner.line_width_granularity = line_width_granularity;
         self
     }
+    #[inline]
     pub fn strict_lines(mut self, strict_lines: bool) -> Self {
         self.inner.strict_lines = strict_lines.into();
         self
     }
+    #[inline]
     pub fn standard_sample_locations(mut self, standard_sample_locations: bool) -> Self {
         self.inner.standard_sample_locations = standard_sample_locations.into();
         self
     }
+    #[inline]
     pub fn optimal_buffer_copy_offset_alignment(
         mut self,
         optimal_buffer_copy_offset_alignment: DeviceSize,
@@ -8961,6 +10023,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
         self.inner.optimal_buffer_copy_offset_alignment = optimal_buffer_copy_offset_alignment;
         self
     }
+    #[inline]
     pub fn optimal_buffer_copy_row_pitch_alignment(
         mut self,
         optimal_buffer_copy_row_pitch_alignment: DeviceSize,
@@ -8969,6 +10032,7 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
             optimal_buffer_copy_row_pitch_alignment;
         self
     }
+    #[inline]
     pub fn non_coherent_atom_size(mut self, non_coherent_atom_size: DeviceSize) -> Self {
         self.inner.non_coherent_atom_size = non_coherent_atom_size;
         self
@@ -8981,26 +10045,31 @@ impl<'a> PhysicalDeviceLimitsBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreCreateInfo.html>"]
 pub struct SemaphoreCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: SemaphoreCreateFlags,
 }
 impl ::std::default::Default for SemaphoreCreateInfo {
-    fn default() -> SemaphoreCreateInfo {
-        SemaphoreCreateInfo {
-            s_type: StructureType::SEMAPHORE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: SemaphoreCreateFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SemaphoreCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_CREATE_INFO;
+}
 impl SemaphoreCreateInfo {
     pub fn builder<'a>() -> SemaphoreCreateInfoBuilder<'a> {
         SemaphoreCreateInfoBuilder {
-            inner: SemaphoreCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9023,6 +10092,7 @@ impl<'a> ::std::ops::DerefMut for SemaphoreCreateInfoBuilder<'a> {
     }
 }
 impl<'a> SemaphoreCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: SemaphoreCreateFlags) -> Self {
         self.inner.flags = flags;
         self
@@ -9034,10 +10104,10 @@ impl<'a> SemaphoreCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsSemaphoreCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -9049,8 +10119,9 @@ impl<'a> SemaphoreCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolCreateInfo.html>"]
 pub struct QueryPoolCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -9060,9 +10131,10 @@ pub struct QueryPoolCreateInfo {
     pub pipeline_statistics: QueryPipelineStatisticFlags,
 }
 impl ::std::default::Default for QueryPoolCreateInfo {
-    fn default() -> QueryPoolCreateInfo {
-        QueryPoolCreateInfo {
-            s_type: StructureType::QUERY_POOL_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: QueryPoolCreateFlags::default(),
             query_type: QueryType::default(),
@@ -9071,10 +10143,13 @@ impl ::std::default::Default for QueryPoolCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for QueryPoolCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::QUERY_POOL_CREATE_INFO;
+}
 impl QueryPoolCreateInfo {
     pub fn builder<'a>() -> QueryPoolCreateInfoBuilder<'a> {
         QueryPoolCreateInfoBuilder {
-            inner: QueryPoolCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9097,18 +10172,22 @@ impl<'a> ::std::ops::DerefMut for QueryPoolCreateInfoBuilder<'a> {
     }
 }
 impl<'a> QueryPoolCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: QueryPoolCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn query_type(mut self, query_type: QueryType) -> Self {
         self.inner.query_type = query_type;
         self
     }
+    #[inline]
     pub fn query_count(mut self, query_count: u32) -> Self {
         self.inner.query_count = query_count;
         self
     }
+    #[inline]
     pub fn pipeline_statistics(mut self, pipeline_statistics: QueryPipelineStatisticFlags) -> Self {
         self.inner.pipeline_statistics = pipeline_statistics;
         self
@@ -9120,10 +10199,10 @@ impl<'a> QueryPoolCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsQueryPoolCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -9135,8 +10214,9 @@ impl<'a> QueryPoolCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferCreateInfo.html>"]
 pub struct FramebufferCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -9149,9 +10229,10 @@ pub struct FramebufferCreateInfo {
     pub layers: u32,
 }
 impl ::std::default::Default for FramebufferCreateInfo {
-    fn default() -> FramebufferCreateInfo {
-        FramebufferCreateInfo {
-            s_type: StructureType::FRAMEBUFFER_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: FramebufferCreateFlags::default(),
             render_pass: RenderPass::default(),
@@ -9163,10 +10244,13 @@ impl ::std::default::Default for FramebufferCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for FramebufferCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_CREATE_INFO;
+}
 impl FramebufferCreateInfo {
     pub fn builder<'a>() -> FramebufferCreateInfoBuilder<'a> {
         FramebufferCreateInfoBuilder {
-            inner: FramebufferCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9189,27 +10273,38 @@ impl<'a> ::std::ops::DerefMut for FramebufferCreateInfoBuilder<'a> {
     }
 }
 impl<'a> FramebufferCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: FramebufferCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
         self.inner.render_pass = render_pass;
         self
     }
+    #[inline]
+    pub fn attachment_count(mut self, attachment_count: u32) -> Self {
+        self.inner.attachment_count = attachment_count;
+        self
+    }
+    #[inline]
     pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self {
         self.inner.attachment_count = attachments.len() as _;
         self.inner.p_attachments = attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn width(mut self, width: u32) -> Self {
         self.inner.width = width;
         self
     }
+    #[inline]
     pub fn height(mut self, height: u32) -> Self {
         self.inner.height = height;
         self
     }
+    #[inline]
     pub fn layers(mut self, layers: u32) -> Self {
         self.inner.layers = layers;
         self
@@ -9221,10 +10316,10 @@ impl<'a> FramebufferCreateInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsFramebufferCreateInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -9236,8 +10331,9 @@ impl<'a> FramebufferCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrawIndirectCommand.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndirectCommand.html>"]
 pub struct DrawIndirectCommand {
     pub vertex_count: u32,
     pub instance_count: u32,
@@ -9247,7 +10343,7 @@ pub struct DrawIndirectCommand {
 impl DrawIndirectCommand {
     pub fn builder<'a>() -> DrawIndirectCommandBuilder<'a> {
         DrawIndirectCommandBuilder {
-            inner: DrawIndirectCommand::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9269,18 +10365,22 @@ impl<'a> ::std::ops::DerefMut for DrawIndirectCommandBuilder<'a> {
     }
 }
 impl<'a> DrawIndirectCommandBuilder<'a> {
+    #[inline]
     pub fn vertex_count(mut self, vertex_count: u32) -> Self {
         self.inner.vertex_count = vertex_count;
         self
     }
+    #[inline]
     pub fn instance_count(mut self, instance_count: u32) -> Self {
         self.inner.instance_count = instance_count;
         self
     }
+    #[inline]
     pub fn first_vertex(mut self, first_vertex: u32) -> Self {
         self.inner.first_vertex = first_vertex;
         self
     }
+    #[inline]
     pub fn first_instance(mut self, first_instance: u32) -> Self {
         self.inner.first_instance = first_instance;
         self
@@ -9293,8 +10393,9 @@ impl<'a> DrawIndirectCommandBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrawIndexedIndirectCommand.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawIndexedIndirectCommand.html>"]
 pub struct DrawIndexedIndirectCommand {
     pub index_count: u32,
     pub instance_count: u32,
@@ -9305,7 +10406,7 @@ pub struct DrawIndexedIndirectCommand {
 impl DrawIndexedIndirectCommand {
     pub fn builder<'a>() -> DrawIndexedIndirectCommandBuilder<'a> {
         DrawIndexedIndirectCommandBuilder {
-            inner: DrawIndexedIndirectCommand::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9327,22 +10428,27 @@ impl<'a> ::std::ops::DerefMut for DrawIndexedIndirectCommandBuilder<'a> {
     }
 }
 impl<'a> DrawIndexedIndirectCommandBuilder<'a> {
+    #[inline]
     pub fn index_count(mut self, index_count: u32) -> Self {
         self.inner.index_count = index_count;
         self
     }
+    #[inline]
     pub fn instance_count(mut self, instance_count: u32) -> Self {
         self.inner.instance_count = instance_count;
         self
     }
+    #[inline]
     pub fn first_index(mut self, first_index: u32) -> Self {
         self.inner.first_index = first_index;
         self
     }
+    #[inline]
     pub fn vertex_offset(mut self, vertex_offset: i32) -> Self {
         self.inner.vertex_offset = vertex_offset;
         self
     }
+    #[inline]
     pub fn first_instance(mut self, first_instance: u32) -> Self {
         self.inner.first_instance = first_instance;
         self
@@ -9355,8 +10461,9 @@ impl<'a> DrawIndexedIndirectCommandBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDispatchIndirectCommand.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDispatchIndirectCommand.html>"]
 pub struct DispatchIndirectCommand {
     pub x: u32,
     pub y: u32,
@@ -9365,7 +10472,7 @@ pub struct DispatchIndirectCommand {
 impl DispatchIndirectCommand {
     pub fn builder<'a>() -> DispatchIndirectCommandBuilder<'a> {
         DispatchIndirectCommandBuilder {
-            inner: DispatchIndirectCommand::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9387,14 +10494,17 @@ impl<'a> ::std::ops::DerefMut for DispatchIndirectCommandBuilder<'a> {
     }
 }
 impl<'a> DispatchIndirectCommandBuilder<'a> {
+    #[inline]
     pub fn x(mut self, x: u32) -> Self {
         self.inner.x = x;
         self
     }
+    #[inline]
     pub fn y(mut self, y: u32) -> Self {
         self.inner.y = y;
         self
     }
+    #[inline]
     pub fn z(mut self, z: u32) -> Self {
         self.inner.z = z;
         self
@@ -9407,8 +10517,9 @@ impl<'a> DispatchIndirectCommandBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMultiDrawInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawInfoEXT.html>"]
 pub struct MultiDrawInfoEXT {
     pub first_vertex: u32,
     pub vertex_count: u32,
@@ -9416,7 +10527,7 @@ pub struct MultiDrawInfoEXT {
 impl MultiDrawInfoEXT {
     pub fn builder<'a>() -> MultiDrawInfoEXTBuilder<'a> {
         MultiDrawInfoEXTBuilder {
-            inner: MultiDrawInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9438,10 +10549,12 @@ impl<'a> ::std::ops::DerefMut for MultiDrawInfoEXTBuilder<'a> {
     }
 }
 impl<'a> MultiDrawInfoEXTBuilder<'a> {
+    #[inline]
     pub fn first_vertex(mut self, first_vertex: u32) -> Self {
         self.inner.first_vertex = first_vertex;
         self
     }
+    #[inline]
     pub fn vertex_count(mut self, vertex_count: u32) -> Self {
         self.inner.vertex_count = vertex_count;
         self
@@ -9454,8 +10567,9 @@ impl<'a> MultiDrawInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMultiDrawIndexedInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiDrawIndexedInfoEXT.html>"]
 pub struct MultiDrawIndexedInfoEXT {
     pub first_index: u32,
     pub index_count: u32,
@@ -9464,7 +10578,7 @@ pub struct MultiDrawIndexedInfoEXT {
 impl MultiDrawIndexedInfoEXT {
     pub fn builder<'a>() -> MultiDrawIndexedInfoEXTBuilder<'a> {
         MultiDrawIndexedInfoEXTBuilder {
-            inner: MultiDrawIndexedInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9486,14 +10600,17 @@ impl<'a> ::std::ops::DerefMut for MultiDrawIndexedInfoEXTBuilder<'a> {
     }
 }
 impl<'a> MultiDrawIndexedInfoEXTBuilder<'a> {
+    #[inline]
     pub fn first_index(mut self, first_index: u32) -> Self {
         self.inner.first_index = first_index;
         self
     }
+    #[inline]
     pub fn index_count(mut self, index_count: u32) -> Self {
         self.inner.index_count = index_count;
         self
     }
+    #[inline]
     pub fn vertex_offset(mut self, vertex_offset: i32) -> Self {
         self.inner.vertex_offset = vertex_offset;
         self
@@ -9506,8 +10623,9 @@ impl<'a> MultiDrawIndexedInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubmitInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo.html>"]
 pub struct SubmitInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -9520,9 +10638,10 @@ pub struct SubmitInfo {
     pub p_signal_semaphores: *const Semaphore,
 }
 impl ::std::default::Default for SubmitInfo {
-    fn default() -> SubmitInfo {
-        SubmitInfo {
-            s_type: StructureType::SUBMIT_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             wait_semaphore_count: u32::default(),
             p_wait_semaphores: ::std::ptr::null(),
@@ -9534,10 +10653,13 @@ impl ::std::default::Default for SubmitInfo {
         }
     }
 }
+unsafe impl TaggedStructure for SubmitInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SUBMIT_INFO;
+}
 impl SubmitInfo {
     pub fn builder<'a>() -> SubmitInfoBuilder<'a> {
         SubmitInfoBuilder {
-            inner: SubmitInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9560,21 +10682,25 @@ impl<'a> ::std::ops::DerefMut for SubmitInfoBuilder<'a> {
     }
 }
 impl<'a> SubmitInfoBuilder<'a> {
+    #[inline]
     pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
         self.inner.wait_semaphore_count = wait_semaphores.len() as _;
         self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
         self
     }
+    #[inline]
     pub fn wait_dst_stage_mask(mut self, wait_dst_stage_mask: &'a [PipelineStageFlags]) -> Self {
         self.inner.wait_semaphore_count = wait_dst_stage_mask.len() as _;
         self.inner.p_wait_dst_stage_mask = wait_dst_stage_mask.as_ptr();
         self
     }
+    #[inline]
     pub fn command_buffers(mut self, command_buffers: &'a [CommandBuffer]) -> Self {
         self.inner.command_buffer_count = command_buffers.len() as _;
         self.inner.p_command_buffers = command_buffers.as_ptr();
         self
     }
+    #[inline]
     pub fn signal_semaphores(mut self, signal_semaphores: &'a [Semaphore]) -> Self {
         self.inner.signal_semaphore_count = signal_semaphores.len() as _;
         self.inner.p_signal_semaphores = signal_semaphores.as_ptr();
@@ -9587,10 +10713,10 @@ impl<'a> SubmitInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsSubmitInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -9602,8 +10728,9 @@ impl<'a> SubmitInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPropertiesKHR.html>"]
 pub struct DisplayPropertiesKHR {
     pub display: DisplayKHR,
     pub display_name: *const c_char,
@@ -9614,8 +10741,9 @@ pub struct DisplayPropertiesKHR {
     pub persistent_content: Bool32,
 }
 impl ::std::default::Default for DisplayPropertiesKHR {
-    fn default() -> DisplayPropertiesKHR {
-        DisplayPropertiesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
             display: DisplayKHR::default(),
             display_name: ::std::ptr::null(),
             physical_dimensions: Extent2D::default(),
@@ -9629,7 +10757,7 @@ impl ::std::default::Default for DisplayPropertiesKHR {
 impl DisplayPropertiesKHR {
     pub fn builder<'a>() -> DisplayPropertiesKHRBuilder<'a> {
         DisplayPropertiesKHRBuilder {
-            inner: DisplayPropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9651,30 +10779,37 @@ impl<'a> ::std::ops::DerefMut for DisplayPropertiesKHRBuilder<'a> {
     }
 }
 impl<'a> DisplayPropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn display(mut self, display: DisplayKHR) -> Self {
         self.inner.display = display;
         self
     }
+    #[inline]
     pub fn display_name(mut self, display_name: &'a ::std::ffi::CStr) -> Self {
         self.inner.display_name = display_name.as_ptr();
         self
     }
+    #[inline]
     pub fn physical_dimensions(mut self, physical_dimensions: Extent2D) -> Self {
         self.inner.physical_dimensions = physical_dimensions;
         self
     }
+    #[inline]
     pub fn physical_resolution(mut self, physical_resolution: Extent2D) -> Self {
         self.inner.physical_resolution = physical_resolution;
         self
     }
+    #[inline]
     pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
         self.inner.supported_transforms = supported_transforms;
         self
     }
+    #[inline]
     pub fn plane_reorder_possible(mut self, plane_reorder_possible: bool) -> Self {
         self.inner.plane_reorder_possible = plane_reorder_possible.into();
         self
     }
+    #[inline]
     pub fn persistent_content(mut self, persistent_content: bool) -> Self {
         self.inner.persistent_content = persistent_content.into();
         self
@@ -9687,8 +10822,9 @@ impl<'a> DisplayPropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlanePropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlanePropertiesKHR.html>"]
 pub struct DisplayPlanePropertiesKHR {
     pub current_display: DisplayKHR,
     pub current_stack_index: u32,
@@ -9696,7 +10832,7 @@ pub struct DisplayPlanePropertiesKHR {
 impl DisplayPlanePropertiesKHR {
     pub fn builder<'a>() -> DisplayPlanePropertiesKHRBuilder<'a> {
         DisplayPlanePropertiesKHRBuilder {
-            inner: DisplayPlanePropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9718,10 +10854,12 @@ impl<'a> ::std::ops::DerefMut for DisplayPlanePropertiesKHRBuilder<'a> {
     }
 }
 impl<'a> DisplayPlanePropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn current_display(mut self, current_display: DisplayKHR) -> Self {
         self.inner.current_display = current_display;
         self
     }
+    #[inline]
     pub fn current_stack_index(mut self, current_stack_index: u32) -> Self {
         self.inner.current_stack_index = current_stack_index;
         self
@@ -9734,8 +10872,9 @@ impl<'a> DisplayPlanePropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeParametersKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeParametersKHR.html>"]
 pub struct DisplayModeParametersKHR {
     pub visible_region: Extent2D,
     pub refresh_rate: u32,
@@ -9743,7 +10882,7 @@ pub struct DisplayModeParametersKHR {
 impl DisplayModeParametersKHR {
     pub fn builder<'a>() -> DisplayModeParametersKHRBuilder<'a> {
         DisplayModeParametersKHRBuilder {
-            inner: DisplayModeParametersKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9765,10 +10904,12 @@ impl<'a> ::std::ops::DerefMut for DisplayModeParametersKHRBuilder<'a> {
     }
 }
 impl<'a> DisplayModeParametersKHRBuilder<'a> {
+    #[inline]
     pub fn visible_region(mut self, visible_region: Extent2D) -> Self {
         self.inner.visible_region = visible_region;
         self
     }
+    #[inline]
     pub fn refresh_rate(mut self, refresh_rate: u32) -> Self {
         self.inner.refresh_rate = refresh_rate;
         self
@@ -9781,8 +10922,9 @@ impl<'a> DisplayModeParametersKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModePropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModePropertiesKHR.html>"]
 pub struct DisplayModePropertiesKHR {
     pub display_mode: DisplayModeKHR,
     pub parameters: DisplayModeParametersKHR,
@@ -9790,7 +10932,7 @@ pub struct DisplayModePropertiesKHR {
 impl DisplayModePropertiesKHR {
     pub fn builder<'a>() -> DisplayModePropertiesKHRBuilder<'a> {
         DisplayModePropertiesKHRBuilder {
-            inner: DisplayModePropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9812,10 +10954,12 @@ impl<'a> ::std::ops::DerefMut for DisplayModePropertiesKHRBuilder<'a> {
     }
 }
 impl<'a> DisplayModePropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self {
         self.inner.display_mode = display_mode;
         self
     }
+    #[inline]
     pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self {
         self.inner.parameters = parameters;
         self
@@ -9828,8 +10972,9 @@ impl<'a> DisplayModePropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeCreateInfoKHR.html>"]
 pub struct DisplayModeCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -9837,19 +10982,23 @@ pub struct DisplayModeCreateInfoKHR {
     pub parameters: DisplayModeParametersKHR,
 }
 impl ::std::default::Default for DisplayModeCreateInfoKHR {
-    fn default() -> DisplayModeCreateInfoKHR {
-        DisplayModeCreateInfoKHR {
-            s_type: StructureType::DISPLAY_MODE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DisplayModeCreateFlagsKHR::default(),
             parameters: DisplayModeParametersKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DisplayModeCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_MODE_CREATE_INFO_KHR;
+}
 impl DisplayModeCreateInfoKHR {
     pub fn builder<'a>() -> DisplayModeCreateInfoKHRBuilder<'a> {
         DisplayModeCreateInfoKHRBuilder {
-            inner: DisplayModeCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9871,10 +11020,12 @@ impl<'a> ::std::ops::DerefMut for DisplayModeCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> DisplayModeCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DisplayModeCreateFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn parameters(mut self, parameters: DisplayModeParametersKHR) -> Self {
         self.inner.parameters = parameters;
         self
@@ -9887,8 +11038,9 @@ impl<'a> DisplayModeCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneCapabilitiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilitiesKHR.html>"]
 pub struct DisplayPlaneCapabilitiesKHR {
     pub supported_alpha: DisplayPlaneAlphaFlagsKHR,
     pub min_src_position: Offset2D,
@@ -9903,7 +11055,7 @@ pub struct DisplayPlaneCapabilitiesKHR {
 impl DisplayPlaneCapabilitiesKHR {
     pub fn builder<'a>() -> DisplayPlaneCapabilitiesKHRBuilder<'a> {
         DisplayPlaneCapabilitiesKHRBuilder {
-            inner: DisplayPlaneCapabilitiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -9925,38 +11077,47 @@ impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilitiesKHRBuilder<'a> {
     }
 }
 impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> {
+    #[inline]
     pub fn supported_alpha(mut self, supported_alpha: DisplayPlaneAlphaFlagsKHR) -> Self {
         self.inner.supported_alpha = supported_alpha;
         self
     }
+    #[inline]
     pub fn min_src_position(mut self, min_src_position: Offset2D) -> Self {
         self.inner.min_src_position = min_src_position;
         self
     }
+    #[inline]
     pub fn max_src_position(mut self, max_src_position: Offset2D) -> Self {
         self.inner.max_src_position = max_src_position;
         self
     }
+    #[inline]
     pub fn min_src_extent(mut self, min_src_extent: Extent2D) -> Self {
         self.inner.min_src_extent = min_src_extent;
         self
     }
+    #[inline]
     pub fn max_src_extent(mut self, max_src_extent: Extent2D) -> Self {
         self.inner.max_src_extent = max_src_extent;
         self
     }
+    #[inline]
     pub fn min_dst_position(mut self, min_dst_position: Offset2D) -> Self {
         self.inner.min_dst_position = min_dst_position;
         self
     }
+    #[inline]
     pub fn max_dst_position(mut self, max_dst_position: Offset2D) -> Self {
         self.inner.max_dst_position = max_dst_position;
         self
     }
+    #[inline]
     pub fn min_dst_extent(mut self, min_dst_extent: Extent2D) -> Self {
         self.inner.min_dst_extent = min_dst_extent;
         self
     }
+    #[inline]
     pub fn max_dst_extent(mut self, max_dst_extent: Extent2D) -> Self {
         self.inner.max_dst_extent = max_dst_extent;
         self
@@ -9969,8 +11130,9 @@ impl<'a> DisplayPlaneCapabilitiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplaySurfaceCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplaySurfaceCreateInfoKHR.html>"]
 pub struct DisplaySurfaceCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -9984,9 +11146,10 @@ pub struct DisplaySurfaceCreateInfoKHR {
     pub image_extent: Extent2D,
 }
 impl ::std::default::Default for DisplaySurfaceCreateInfoKHR {
-    fn default() -> DisplaySurfaceCreateInfoKHR {
-        DisplaySurfaceCreateInfoKHR {
-            s_type: StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DisplaySurfaceCreateFlagsKHR::default(),
             display_mode: DisplayModeKHR::default(),
@@ -9999,10 +11162,13 @@ impl ::std::default::Default for DisplaySurfaceCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for DisplaySurfaceCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_SURFACE_CREATE_INFO_KHR;
+}
 impl DisplaySurfaceCreateInfoKHR {
     pub fn builder<'a>() -> DisplaySurfaceCreateInfoKHRBuilder<'a> {
         DisplaySurfaceCreateInfoKHRBuilder {
-            inner: DisplaySurfaceCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10024,34 +11190,42 @@ impl<'a> ::std::ops::DerefMut for DisplaySurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DisplaySurfaceCreateFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn display_mode(mut self, display_mode: DisplayModeKHR) -> Self {
         self.inner.display_mode = display_mode;
         self
     }
+    #[inline]
     pub fn plane_index(mut self, plane_index: u32) -> Self {
         self.inner.plane_index = plane_index;
         self
     }
+    #[inline]
     pub fn plane_stack_index(mut self, plane_stack_index: u32) -> Self {
         self.inner.plane_stack_index = plane_stack_index;
         self
     }
+    #[inline]
     pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
         self.inner.transform = transform;
         self
     }
+    #[inline]
     pub fn global_alpha(mut self, global_alpha: f32) -> Self {
         self.inner.global_alpha = global_alpha;
         self
     }
+    #[inline]
     pub fn alpha_mode(mut self, alpha_mode: DisplayPlaneAlphaFlagsKHR) -> Self {
         self.inner.alpha_mode = alpha_mode;
         self
     }
+    #[inline]
     pub fn image_extent(mut self, image_extent: Extent2D) -> Self {
         self.inner.image_extent = image_extent;
         self
@@ -10064,8 +11238,9 @@ impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPresentInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPresentInfoKHR.html>"]
 pub struct DisplayPresentInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10074,9 +11249,10 @@ pub struct DisplayPresentInfoKHR {
     pub persistent: Bool32,
 }
 impl ::std::default::Default for DisplayPresentInfoKHR {
-    fn default() -> DisplayPresentInfoKHR {
-        DisplayPresentInfoKHR {
-            s_type: StructureType::DISPLAY_PRESENT_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_rect: Rect2D::default(),
             dst_rect: Rect2D::default(),
@@ -10084,10 +11260,13 @@ impl ::std::default::Default for DisplayPresentInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for DisplayPresentInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PRESENT_INFO_KHR;
+}
 impl DisplayPresentInfoKHR {
     pub fn builder<'a>() -> DisplayPresentInfoKHRBuilder<'a> {
         DisplayPresentInfoKHRBuilder {
-            inner: DisplayPresentInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10111,14 +11290,17 @@ impl<'a> ::std::ops::DerefMut for DisplayPresentInfoKHRBuilder<'a> {
     }
 }
 impl<'a> DisplayPresentInfoKHRBuilder<'a> {
+    #[inline]
     pub fn src_rect(mut self, src_rect: Rect2D) -> Self {
         self.inner.src_rect = src_rect;
         self
     }
+    #[inline]
     pub fn dst_rect(mut self, dst_rect: Rect2D) -> Self {
         self.inner.dst_rect = dst_rect;
         self
     }
+    #[inline]
     pub fn persistent(mut self, persistent: bool) -> Self {
         self.inner.persistent = persistent.into();
         self
@@ -10131,8 +11313,9 @@ impl<'a> DisplayPresentInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilitiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesKHR.html>"]
 pub struct SurfaceCapabilitiesKHR {
     pub min_image_count: u32,
     pub max_image_count: u32,
@@ -10148,7 +11331,7 @@ pub struct SurfaceCapabilitiesKHR {
 impl SurfaceCapabilitiesKHR {
     pub fn builder<'a>() -> SurfaceCapabilitiesKHRBuilder<'a> {
         SurfaceCapabilitiesKHRBuilder {
-            inner: SurfaceCapabilitiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10170,38 +11353,47 @@ impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesKHRBuilder<'a> {
     }
 }
 impl<'a> SurfaceCapabilitiesKHRBuilder<'a> {
+    #[inline]
     pub fn min_image_count(mut self, min_image_count: u32) -> Self {
         self.inner.min_image_count = min_image_count;
         self
     }
+    #[inline]
     pub fn max_image_count(mut self, max_image_count: u32) -> Self {
         self.inner.max_image_count = max_image_count;
         self
     }
+    #[inline]
     pub fn current_extent(mut self, current_extent: Extent2D) -> Self {
         self.inner.current_extent = current_extent;
         self
     }
+    #[inline]
     pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self {
         self.inner.min_image_extent = min_image_extent;
         self
     }
+    #[inline]
     pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self {
         self.inner.max_image_extent = max_image_extent;
         self
     }
+    #[inline]
     pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
         self.inner.max_image_array_layers = max_image_array_layers;
         self
     }
+    #[inline]
     pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
         self.inner.supported_transforms = supported_transforms;
         self
     }
+    #[inline]
     pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self {
         self.inner.current_transform = current_transform;
         self
     }
+    #[inline]
     pub fn supported_composite_alpha(
         mut self,
         supported_composite_alpha: CompositeAlphaFlagsKHR,
@@ -10209,6 +11401,7 @@ impl<'a> SurfaceCapabilitiesKHRBuilder<'a> {
         self.inner.supported_composite_alpha = supported_composite_alpha;
         self
     }
+    #[inline]
     pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self {
         self.inner.supported_usage_flags = supported_usage_flags;
         self
@@ -10221,8 +11414,9 @@ impl<'a> SurfaceCapabilitiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidSurfaceCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidSurfaceCreateInfoKHR.html>"]
 pub struct AndroidSurfaceCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10230,19 +11424,23 @@ pub struct AndroidSurfaceCreateInfoKHR {
     pub window: *mut ANativeWindow,
 }
 impl ::std::default::Default for AndroidSurfaceCreateInfoKHR {
-    fn default() -> AndroidSurfaceCreateInfoKHR {
-        AndroidSurfaceCreateInfoKHR {
-            s_type: StructureType::ANDROID_SURFACE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: AndroidSurfaceCreateFlagsKHR::default(),
             window: ::std::ptr::null_mut(),
         }
     }
 }
+unsafe impl TaggedStructure for AndroidSurfaceCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_SURFACE_CREATE_INFO_KHR;
+}
 impl AndroidSurfaceCreateInfoKHR {
     pub fn builder<'a>() -> AndroidSurfaceCreateInfoKHRBuilder<'a> {
         AndroidSurfaceCreateInfoKHRBuilder {
-            inner: AndroidSurfaceCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10264,10 +11462,12 @@ impl<'a> ::std::ops::DerefMut for AndroidSurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: AndroidSurfaceCreateFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn window(mut self, window: *mut ANativeWindow) -> Self {
         self.inner.window = window;
         self
@@ -10280,8 +11480,9 @@ impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViSurfaceCreateInfoNN.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViSurfaceCreateInfoNN.html>"]
 pub struct ViSurfaceCreateInfoNN {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10289,19 +11490,23 @@ pub struct ViSurfaceCreateInfoNN {
     pub window: *mut c_void,
 }
 impl ::std::default::Default for ViSurfaceCreateInfoNN {
-    fn default() -> ViSurfaceCreateInfoNN {
-        ViSurfaceCreateInfoNN {
-            s_type: StructureType::VI_SURFACE_CREATE_INFO_NN,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: ViSurfaceCreateFlagsNN::default(),
             window: ::std::ptr::null_mut(),
         }
     }
 }
+unsafe impl TaggedStructure for ViSurfaceCreateInfoNN {
+    const STRUCTURE_TYPE: StructureType = StructureType::VI_SURFACE_CREATE_INFO_NN;
+}
 impl ViSurfaceCreateInfoNN {
     pub fn builder<'a>() -> ViSurfaceCreateInfoNNBuilder<'a> {
         ViSurfaceCreateInfoNNBuilder {
-            inner: ViSurfaceCreateInfoNN::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10323,10 +11528,12 @@ impl<'a> ::std::ops::DerefMut for ViSurfaceCreateInfoNNBuilder<'a> {
     }
 }
 impl<'a> ViSurfaceCreateInfoNNBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: ViSurfaceCreateFlagsNN) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn window(mut self, window: *mut c_void) -> Self {
         self.inner.window = window;
         self
@@ -10339,8 +11546,9 @@ impl<'a> ViSurfaceCreateInfoNNBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWaylandSurfaceCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWaylandSurfaceCreateInfoKHR.html>"]
 pub struct WaylandSurfaceCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10349,9 +11557,10 @@ pub struct WaylandSurfaceCreateInfoKHR {
     pub surface: *mut wl_surface,
 }
 impl ::std::default::Default for WaylandSurfaceCreateInfoKHR {
-    fn default() -> WaylandSurfaceCreateInfoKHR {
-        WaylandSurfaceCreateInfoKHR {
-            s_type: StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: WaylandSurfaceCreateFlagsKHR::default(),
             display: ::std::ptr::null_mut(),
@@ -10359,10 +11568,13 @@ impl ::std::default::Default for WaylandSurfaceCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for WaylandSurfaceCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::WAYLAND_SURFACE_CREATE_INFO_KHR;
+}
 impl WaylandSurfaceCreateInfoKHR {
     pub fn builder<'a>() -> WaylandSurfaceCreateInfoKHRBuilder<'a> {
         WaylandSurfaceCreateInfoKHRBuilder {
-            inner: WaylandSurfaceCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10384,14 +11596,17 @@ impl<'a> ::std::ops::DerefMut for WaylandSurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: WaylandSurfaceCreateFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn display(mut self, display: *mut wl_display) -> Self {
         self.inner.display = display;
         self
     }
+    #[inline]
     pub fn surface(mut self, surface: *mut wl_surface) -> Self {
         self.inner.surface = surface;
         self
@@ -10404,8 +11619,9 @@ impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32SurfaceCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32SurfaceCreateInfoKHR.html>"]
 pub struct Win32SurfaceCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10414,9 +11630,10 @@ pub struct Win32SurfaceCreateInfoKHR {
     pub hwnd: HWND,
 }
 impl ::std::default::Default for Win32SurfaceCreateInfoKHR {
-    fn default() -> Win32SurfaceCreateInfoKHR {
-        Win32SurfaceCreateInfoKHR {
-            s_type: StructureType::WIN32_SURFACE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: Win32SurfaceCreateFlagsKHR::default(),
             hinstance: unsafe { ::std::mem::zeroed() },
@@ -10424,10 +11641,13 @@ impl ::std::default::Default for Win32SurfaceCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for Win32SurfaceCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::WIN32_SURFACE_CREATE_INFO_KHR;
+}
 impl Win32SurfaceCreateInfoKHR {
     pub fn builder<'a>() -> Win32SurfaceCreateInfoKHRBuilder<'a> {
         Win32SurfaceCreateInfoKHRBuilder {
-            inner: Win32SurfaceCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10449,14 +11669,17 @@ impl<'a> ::std::ops::DerefMut for Win32SurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: Win32SurfaceCreateFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn hinstance(mut self, hinstance: HINSTANCE) -> Self {
         self.inner.hinstance = hinstance;
         self
     }
+    #[inline]
     pub fn hwnd(mut self, hwnd: HWND) -> Self {
         self.inner.hwnd = hwnd;
         self
@@ -10469,8 +11692,9 @@ impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXlibSurfaceCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXlibSurfaceCreateInfoKHR.html>"]
 pub struct XlibSurfaceCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10479,9 +11703,10 @@ pub struct XlibSurfaceCreateInfoKHR {
     pub window: Window,
 }
 impl ::std::default::Default for XlibSurfaceCreateInfoKHR {
-    fn default() -> XlibSurfaceCreateInfoKHR {
-        XlibSurfaceCreateInfoKHR {
-            s_type: StructureType::XLIB_SURFACE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: XlibSurfaceCreateFlagsKHR::default(),
             dpy: ::std::ptr::null_mut(),
@@ -10489,10 +11714,13 @@ impl ::std::default::Default for XlibSurfaceCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for XlibSurfaceCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::XLIB_SURFACE_CREATE_INFO_KHR;
+}
 impl XlibSurfaceCreateInfoKHR {
     pub fn builder<'a>() -> XlibSurfaceCreateInfoKHRBuilder<'a> {
         XlibSurfaceCreateInfoKHRBuilder {
-            inner: XlibSurfaceCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10514,14 +11742,17 @@ impl<'a> ::std::ops::DerefMut for XlibSurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: XlibSurfaceCreateFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn dpy(mut self, dpy: *mut Display) -> Self {
         self.inner.dpy = dpy;
         self
     }
+    #[inline]
     pub fn window(mut self, window: Window) -> Self {
         self.inner.window = window;
         self
@@ -10534,8 +11765,9 @@ impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXcbSurfaceCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXcbSurfaceCreateInfoKHR.html>"]
 pub struct XcbSurfaceCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10544,9 +11776,10 @@ pub struct XcbSurfaceCreateInfoKHR {
     pub window: xcb_window_t,
 }
 impl ::std::default::Default for XcbSurfaceCreateInfoKHR {
-    fn default() -> XcbSurfaceCreateInfoKHR {
-        XcbSurfaceCreateInfoKHR {
-            s_type: StructureType::XCB_SURFACE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: XcbSurfaceCreateFlagsKHR::default(),
             connection: ::std::ptr::null_mut(),
@@ -10554,10 +11787,13 @@ impl ::std::default::Default for XcbSurfaceCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for XcbSurfaceCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::XCB_SURFACE_CREATE_INFO_KHR;
+}
 impl XcbSurfaceCreateInfoKHR {
     pub fn builder<'a>() -> XcbSurfaceCreateInfoKHRBuilder<'a> {
         XcbSurfaceCreateInfoKHRBuilder {
-            inner: XcbSurfaceCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10579,14 +11815,17 @@ impl<'a> ::std::ops::DerefMut for XcbSurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: XcbSurfaceCreateFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn connection(mut self, connection: *mut xcb_connection_t) -> Self {
         self.inner.connection = connection;
         self
     }
+    #[inline]
     pub fn window(mut self, window: xcb_window_t) -> Self {
         self.inner.window = window;
         self
@@ -10599,8 +11838,9 @@ impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDirectFBSurfaceCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectFBSurfaceCreateInfoEXT.html>"]
 pub struct DirectFBSurfaceCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10609,9 +11849,10 @@ pub struct DirectFBSurfaceCreateInfoEXT {
     pub surface: *mut IDirectFBSurface,
 }
 impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT {
-    fn default() -> DirectFBSurfaceCreateInfoEXT {
-        DirectFBSurfaceCreateInfoEXT {
-            s_type: StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DirectFBSurfaceCreateFlagsEXT::default(),
             dfb: ::std::ptr::null_mut(),
@@ -10619,10 +11860,13 @@ impl ::std::default::Default for DirectFBSurfaceCreateInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DirectFBSurfaceCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DIRECTFB_SURFACE_CREATE_INFO_EXT;
+}
 impl DirectFBSurfaceCreateInfoEXT {
     pub fn builder<'a>() -> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
         DirectFBSurfaceCreateInfoEXTBuilder {
-            inner: DirectFBSurfaceCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10644,14 +11888,17 @@ impl<'a> ::std::ops::DerefMut for DirectFBSurfaceCreateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DirectFBSurfaceCreateFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn dfb(mut self, dfb: *mut IDirectFB) -> Self {
         self.inner.dfb = dfb;
         self
     }
+    #[inline]
     pub fn surface(mut self, surface: *mut IDirectFBSurface) -> Self {
         self.inner.surface = surface;
         self
@@ -10664,8 +11911,9 @@ impl<'a> DirectFBSurfaceCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html>"]
 pub struct ImagePipeSurfaceCreateInfoFUCHSIA {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10673,19 +11921,23 @@ pub struct ImagePipeSurfaceCreateInfoFUCHSIA {
     pub image_pipe_handle: zx_handle_t,
 }
 impl ::std::default::Default for ImagePipeSurfaceCreateInfoFUCHSIA {
-    fn default() -> ImagePipeSurfaceCreateInfoFUCHSIA {
-        ImagePipeSurfaceCreateInfoFUCHSIA {
-            s_type: StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: ImagePipeSurfaceCreateFlagsFUCHSIA::default(),
             image_pipe_handle: zx_handle_t::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImagePipeSurfaceCreateInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA;
+}
 impl ImagePipeSurfaceCreateInfoFUCHSIA {
     pub fn builder<'a>() -> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
         ImagePipeSurfaceCreateInfoFUCHSIABuilder {
-            inner: ImagePipeSurfaceCreateInfoFUCHSIA::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10707,10 +11959,12 @@ impl<'a> ::std::ops::DerefMut for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
     }
 }
 impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn image_pipe_handle(mut self, image_pipe_handle: zx_handle_t) -> Self {
         self.inner.image_pipe_handle = image_pipe_handle;
         self
@@ -10723,8 +11977,9 @@ impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html>"]
 pub struct StreamDescriptorSurfaceCreateInfoGGP {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10732,19 +11987,23 @@ pub struct StreamDescriptorSurfaceCreateInfoGGP {
     pub stream_descriptor: GgpStreamDescriptor,
 }
 impl ::std::default::Default for StreamDescriptorSurfaceCreateInfoGGP {
-    fn default() -> StreamDescriptorSurfaceCreateInfoGGP {
-        StreamDescriptorSurfaceCreateInfoGGP {
-            s_type: StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: StreamDescriptorSurfaceCreateFlagsGGP::default(),
             stream_descriptor: GgpStreamDescriptor::default(),
         }
     }
 }
+unsafe impl TaggedStructure for StreamDescriptorSurfaceCreateInfoGGP {
+    const STRUCTURE_TYPE: StructureType = StructureType::STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP;
+}
 impl StreamDescriptorSurfaceCreateInfoGGP {
     pub fn builder<'a>() -> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
         StreamDescriptorSurfaceCreateInfoGGPBuilder {
-            inner: StreamDescriptorSurfaceCreateInfoGGP::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10766,10 +12025,12 @@ impl<'a> ::std::ops::DerefMut for StreamDescriptorSurfaceCreateInfoGGPBuilder<'a
     }
 }
 impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: StreamDescriptorSurfaceCreateFlagsGGP) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn stream_descriptor(mut self, stream_descriptor: GgpStreamDescriptor) -> Self {
         self.inner.stream_descriptor = stream_descriptor;
         self
@@ -10782,8 +12043,9 @@ impl<'a> StreamDescriptorSurfaceCreateInfoGGPBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkScreenSurfaceCreateInfoQNX.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkScreenSurfaceCreateInfoQNX.html>"]
 pub struct ScreenSurfaceCreateInfoQNX {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10792,9 +12054,10 @@ pub struct ScreenSurfaceCreateInfoQNX {
     pub window: *mut _screen_window,
 }
 impl ::std::default::Default for ScreenSurfaceCreateInfoQNX {
-    fn default() -> ScreenSurfaceCreateInfoQNX {
-        ScreenSurfaceCreateInfoQNX {
-            s_type: StructureType::SCREEN_SURFACE_CREATE_INFO_QNX,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: ScreenSurfaceCreateFlagsQNX::default(),
             context: ::std::ptr::null_mut(),
@@ -10802,10 +12065,13 @@ impl ::std::default::Default for ScreenSurfaceCreateInfoQNX {
         }
     }
 }
+unsafe impl TaggedStructure for ScreenSurfaceCreateInfoQNX {
+    const STRUCTURE_TYPE: StructureType = StructureType::SCREEN_SURFACE_CREATE_INFO_QNX;
+}
 impl ScreenSurfaceCreateInfoQNX {
     pub fn builder<'a>() -> ScreenSurfaceCreateInfoQNXBuilder<'a> {
         ScreenSurfaceCreateInfoQNXBuilder {
-            inner: ScreenSurfaceCreateInfoQNX::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10827,14 +12093,17 @@ impl<'a> ::std::ops::DerefMut for ScreenSurfaceCreateInfoQNXBuilder<'a> {
     }
 }
 impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: ScreenSurfaceCreateFlagsQNX) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn context(mut self, context: &'a mut _screen_context) -> Self {
         self.inner.context = context;
         self
     }
+    #[inline]
     pub fn window(mut self, window: &'a mut _screen_window) -> Self {
         self.inner.window = window;
         self
@@ -10847,8 +12116,9 @@ impl<'a> ScreenSurfaceCreateInfoQNXBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFormatKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default, PartialEq, Eq, Hash)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormatKHR.html>"]
 pub struct SurfaceFormatKHR {
     pub format: Format,
     pub color_space: ColorSpaceKHR,
@@ -10856,7 +12126,7 @@ pub struct SurfaceFormatKHR {
 impl SurfaceFormatKHR {
     pub fn builder<'a>() -> SurfaceFormatKHRBuilder<'a> {
         SurfaceFormatKHRBuilder {
-            inner: SurfaceFormatKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10878,10 +12148,12 @@ impl<'a> ::std::ops::DerefMut for SurfaceFormatKHRBuilder<'a> {
     }
 }
 impl<'a> SurfaceFormatKHRBuilder<'a> {
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn color_space(mut self, color_space: ColorSpaceKHR) -> Self {
         self.inner.color_space = color_space;
         self
@@ -10894,8 +12166,9 @@ impl<'a> SurfaceFormatKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCreateInfoKHR.html>"]
 pub struct SwapchainCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -10917,9 +12190,10 @@ pub struct SwapchainCreateInfoKHR {
     pub old_swapchain: SwapchainKHR,
 }
 impl ::std::default::Default for SwapchainCreateInfoKHR {
-    fn default() -> SwapchainCreateInfoKHR {
-        SwapchainCreateInfoKHR {
-            s_type: StructureType::SWAPCHAIN_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: SwapchainCreateFlagsKHR::default(),
             surface: SurfaceKHR::default(),
@@ -10940,10 +12214,13 @@ impl ::std::default::Default for SwapchainCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for SwapchainCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_CREATE_INFO_KHR;
+}
 impl SwapchainCreateInfoKHR {
     pub fn builder<'a>() -> SwapchainCreateInfoKHRBuilder<'a> {
         SwapchainCreateInfoKHRBuilder {
-            inner: SwapchainCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -10966,63 +12243,78 @@ impl<'a> ::std::ops::DerefMut for SwapchainCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: SwapchainCreateFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn surface(mut self, surface: SurfaceKHR) -> Self {
         self.inner.surface = surface;
         self
     }
+    #[inline]
     pub fn min_image_count(mut self, min_image_count: u32) -> Self {
         self.inner.min_image_count = min_image_count;
         self
     }
+    #[inline]
     pub fn image_format(mut self, image_format: Format) -> Self {
         self.inner.image_format = image_format;
         self
     }
+    #[inline]
     pub fn image_color_space(mut self, image_color_space: ColorSpaceKHR) -> Self {
         self.inner.image_color_space = image_color_space;
         self
     }
+    #[inline]
     pub fn image_extent(mut self, image_extent: Extent2D) -> Self {
         self.inner.image_extent = image_extent;
         self
     }
+    #[inline]
     pub fn image_array_layers(mut self, image_array_layers: u32) -> Self {
         self.inner.image_array_layers = image_array_layers;
         self
     }
+    #[inline]
     pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self {
         self.inner.image_usage = image_usage;
         self
     }
+    #[inline]
     pub fn image_sharing_mode(mut self, image_sharing_mode: SharingMode) -> Self {
         self.inner.image_sharing_mode = image_sharing_mode;
         self
     }
+    #[inline]
     pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
         self.inner.queue_family_index_count = queue_family_indices.len() as _;
         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
         self
     }
+    #[inline]
     pub fn pre_transform(mut self, pre_transform: SurfaceTransformFlagsKHR) -> Self {
         self.inner.pre_transform = pre_transform;
         self
     }
+    #[inline]
     pub fn composite_alpha(mut self, composite_alpha: CompositeAlphaFlagsKHR) -> Self {
         self.inner.composite_alpha = composite_alpha;
         self
     }
+    #[inline]
     pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self {
         self.inner.present_mode = present_mode;
         self
     }
+    #[inline]
     pub fn clipped(mut self, clipped: bool) -> Self {
         self.inner.clipped = clipped.into();
         self
     }
+    #[inline]
     pub fn old_swapchain(mut self, old_swapchain: SwapchainKHR) -> Self {
         self.inner.old_swapchain = old_swapchain;
         self
@@ -11034,10 +12326,10 @@ impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsSwapchainCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -11049,8 +12341,9 @@ impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentInfoKHR.html>"]
 pub struct PresentInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -11062,9 +12355,10 @@ pub struct PresentInfoKHR {
     pub p_results: *mut Result,
 }
 impl ::std::default::Default for PresentInfoKHR {
-    fn default() -> PresentInfoKHR {
-        PresentInfoKHR {
-            s_type: StructureType::PRESENT_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             wait_semaphore_count: u32::default(),
             p_wait_semaphores: ::std::ptr::null(),
@@ -11075,10 +12369,13 @@ impl ::std::default::Default for PresentInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PresentInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_INFO_KHR;
+}
 impl PresentInfoKHR {
     pub fn builder<'a>() -> PresentInfoKHRBuilder<'a> {
         PresentInfoKHRBuilder {
-            inner: PresentInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11101,21 +12398,25 @@ impl<'a> ::std::ops::DerefMut for PresentInfoKHRBuilder<'a> {
     }
 }
 impl<'a> PresentInfoKHRBuilder<'a> {
+    #[inline]
     pub fn wait_semaphores(mut self, wait_semaphores: &'a [Semaphore]) -> Self {
         self.inner.wait_semaphore_count = wait_semaphores.len() as _;
         self.inner.p_wait_semaphores = wait_semaphores.as_ptr();
         self
     }
+    #[inline]
     pub fn swapchains(mut self, swapchains: &'a [SwapchainKHR]) -> Self {
         self.inner.swapchain_count = swapchains.len() as _;
         self.inner.p_swapchains = swapchains.as_ptr();
         self
     }
+    #[inline]
     pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self {
         self.inner.swapchain_count = image_indices.len() as _;
         self.inner.p_image_indices = image_indices.as_ptr();
         self
     }
+    #[inline]
     pub fn results(mut self, results: &'a mut [Result]) -> Self {
         self.inner.swapchain_count = results.len() as _;
         self.inner.p_results = results.as_mut_ptr();
@@ -11128,10 +12429,10 @@ impl<'a> PresentInfoKHRBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsPresentInfoKHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -11144,7 +12445,7 @@ impl<'a> PresentInfoKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportCallbackCreateInfoEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportCallbackCreateInfoEXT.html>"]
 pub struct DebugReportCallbackCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -11152,6 +12453,7 @@ pub struct DebugReportCallbackCreateInfoEXT {
     pub pfn_callback: PFN_vkDebugReportCallbackEXT,
     pub p_user_data: *mut c_void,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for DebugReportCallbackCreateInfoEXT {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("DebugReportCallbackCreateInfoEXT")
@@ -11164,9 +12466,10 @@ impl fmt::Debug for DebugReportCallbackCreateInfoEXT {
     }
 }
 impl ::std::default::Default for DebugReportCallbackCreateInfoEXT {
-    fn default() -> DebugReportCallbackCreateInfoEXT {
-        DebugReportCallbackCreateInfoEXT {
-            s_type: StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DebugReportFlagsEXT::default(),
             pfn_callback: PFN_vkDebugReportCallbackEXT::default(),
@@ -11174,10 +12477,13 @@ impl ::std::default::Default for DebugReportCallbackCreateInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DebugReportCallbackCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
+}
 impl DebugReportCallbackCreateInfoEXT {
     pub fn builder<'a>() -> DebugReportCallbackCreateInfoEXTBuilder<'a> {
         DebugReportCallbackCreateInfoEXTBuilder {
-            inner: DebugReportCallbackCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11201,14 +12507,17 @@ impl<'a> ::std::ops::DerefMut for DebugReportCallbackCreateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DebugReportFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn pfn_callback(mut self, pfn_callback: PFN_vkDebugReportCallbackEXT) -> Self {
         self.inner.pfn_callback = pfn_callback;
         self
     }
+    #[inline]
     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
         self.inner.p_user_data = user_data;
         self
@@ -11221,8 +12530,9 @@ impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationFlagsEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFlagsEXT.html>"]
 pub struct ValidationFlagsEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -11230,19 +12540,23 @@ pub struct ValidationFlagsEXT {
     pub p_disabled_validation_checks: *const ValidationCheckEXT,
 }
 impl ::std::default::Default for ValidationFlagsEXT {
-    fn default() -> ValidationFlagsEXT {
-        ValidationFlagsEXT {
-            s_type: StructureType::VALIDATION_FLAGS_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             disabled_validation_check_count: u32::default(),
             p_disabled_validation_checks: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for ValidationFlagsEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_FLAGS_EXT;
+}
 impl ValidationFlagsEXT {
     pub fn builder<'a>() -> ValidationFlagsEXTBuilder<'a> {
         ValidationFlagsEXTBuilder {
-            inner: ValidationFlagsEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11266,6 +12580,7 @@ impl<'a> ::std::ops::DerefMut for ValidationFlagsEXTBuilder<'a> {
     }
 }
 impl<'a> ValidationFlagsEXTBuilder<'a> {
+    #[inline]
     pub fn disabled_validation_checks(
         mut self,
         disabled_validation_checks: &'a [ValidationCheckEXT],
@@ -11282,8 +12597,9 @@ impl<'a> ValidationFlagsEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFeaturesEXT.html>"]
 pub struct ValidationFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -11293,9 +12609,10 @@ pub struct ValidationFeaturesEXT {
     pub p_disabled_validation_features: *const ValidationFeatureDisableEXT,
 }
 impl ::std::default::Default for ValidationFeaturesEXT {
-    fn default() -> ValidationFeaturesEXT {
-        ValidationFeaturesEXT {
-            s_type: StructureType::VALIDATION_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             enabled_validation_feature_count: u32::default(),
             p_enabled_validation_features: ::std::ptr::null(),
@@ -11304,10 +12621,13 @@ impl ::std::default::Default for ValidationFeaturesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for ValidationFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_FEATURES_EXT;
+}
 impl ValidationFeaturesEXT {
     pub fn builder<'a>() -> ValidationFeaturesEXTBuilder<'a> {
         ValidationFeaturesEXTBuilder {
-            inner: ValidationFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11331,6 +12651,7 @@ impl<'a> ::std::ops::DerefMut for ValidationFeaturesEXTBuilder<'a> {
     }
 }
 impl<'a> ValidationFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn enabled_validation_features(
         mut self,
         enabled_validation_features: &'a [ValidationFeatureEnableEXT],
@@ -11339,6 +12660,7 @@ impl<'a> ValidationFeaturesEXTBuilder<'a> {
         self.inner.p_enabled_validation_features = enabled_validation_features.as_ptr();
         self
     }
+    #[inline]
     pub fn disabled_validation_features(
         mut self,
         disabled_validation_features: &'a [ValidationFeatureDisableEXT],
@@ -11355,26 +12677,32 @@ impl<'a> ValidationFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html>"]
 pub struct PipelineRasterizationStateRasterizationOrderAMD {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub rasterization_order: RasterizationOrderAMD,
 }
 impl ::std::default::Default for PipelineRasterizationStateRasterizationOrderAMD {
-    fn default() -> PipelineRasterizationStateRasterizationOrderAMD {
-        PipelineRasterizationStateRasterizationOrderAMD {
-            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             rasterization_order: RasterizationOrderAMD::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineRasterizationStateRasterizationOrderAMD {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD;
+}
 impl PipelineRasterizationStateRasterizationOrderAMD {
     pub fn builder<'a>() -> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
         PipelineRasterizationStateRasterizationOrderAMDBuilder {
-            inner: PipelineRasterizationStateRasterizationOrderAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11404,6 +12732,7 @@ impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateRasterizationOrderAM
     }
 }
 impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
+    #[inline]
     pub fn rasterization_order(mut self, rasterization_order: RasterizationOrderAMD) -> Self {
         self.inner.rasterization_order = rasterization_order;
         self
@@ -11416,8 +12745,9 @@ impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugMarkerObjectNameInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectNameInfoEXT.html>"]
 pub struct DebugMarkerObjectNameInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -11426,9 +12756,10 @@ pub struct DebugMarkerObjectNameInfoEXT {
     pub p_object_name: *const c_char,
 }
 impl ::std::default::Default for DebugMarkerObjectNameInfoEXT {
-    fn default() -> DebugMarkerObjectNameInfoEXT {
-        DebugMarkerObjectNameInfoEXT {
-            s_type: StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             object_type: DebugReportObjectTypeEXT::default(),
             object: u64::default(),
@@ -11436,10 +12767,13 @@ impl ::std::default::Default for DebugMarkerObjectNameInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DebugMarkerObjectNameInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_OBJECT_NAME_INFO_EXT;
+}
 impl DebugMarkerObjectNameInfoEXT {
     pub fn builder<'a>() -> DebugMarkerObjectNameInfoEXTBuilder<'a> {
         DebugMarkerObjectNameInfoEXTBuilder {
-            inner: DebugMarkerObjectNameInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11461,14 +12795,17 @@ impl<'a> ::std::ops::DerefMut for DebugMarkerObjectNameInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> {
+    #[inline]
     pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self {
         self.inner.object_type = object_type;
         self
     }
+    #[inline]
     pub fn object(mut self, object: u64) -> Self {
         self.inner.object = object;
         self
     }
+    #[inline]
     pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_object_name = object_name.as_ptr();
         self
@@ -11481,8 +12818,9 @@ impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugMarkerObjectTagInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerObjectTagInfoEXT.html>"]
 pub struct DebugMarkerObjectTagInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -11493,9 +12831,10 @@ pub struct DebugMarkerObjectTagInfoEXT {
     pub p_tag: *const c_void,
 }
 impl ::std::default::Default for DebugMarkerObjectTagInfoEXT {
-    fn default() -> DebugMarkerObjectTagInfoEXT {
-        DebugMarkerObjectTagInfoEXT {
-            s_type: StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             object_type: DebugReportObjectTypeEXT::default(),
             object: u64::default(),
@@ -11505,10 +12844,13 @@ impl ::std::default::Default for DebugMarkerObjectTagInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DebugMarkerObjectTagInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_OBJECT_TAG_INFO_EXT;
+}
 impl DebugMarkerObjectTagInfoEXT {
     pub fn builder<'a>() -> DebugMarkerObjectTagInfoEXTBuilder<'a> {
         DebugMarkerObjectTagInfoEXTBuilder {
-            inner: DebugMarkerObjectTagInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11530,21 +12872,25 @@ impl<'a> ::std::ops::DerefMut for DebugMarkerObjectTagInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> {
+    #[inline]
     pub fn object_type(mut self, object_type: DebugReportObjectTypeEXT) -> Self {
         self.inner.object_type = object_type;
         self
     }
+    #[inline]
     pub fn object(mut self, object: u64) -> Self {
         self.inner.object = object;
         self
     }
+    #[inline]
     pub fn tag_name(mut self, tag_name: u64) -> Self {
         self.inner.tag_name = tag_name;
         self
     }
+    #[inline]
     pub fn tag(mut self, tag: &'a [u8]) -> Self {
-        self.inner.tag_size = tag.len() as _;
-        self.inner.p_tag = tag.as_ptr() as *const c_void;
+        self.inner.tag_size = tag.len();
+        self.inner.p_tag = tag.as_ptr().cast();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -11555,8 +12901,9 @@ impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugMarkerMarkerInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugMarkerMarkerInfoEXT.html>"]
 pub struct DebugMarkerMarkerInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -11564,19 +12911,23 @@ pub struct DebugMarkerMarkerInfoEXT {
     pub color: [f32; 4],
 }
 impl ::std::default::Default for DebugMarkerMarkerInfoEXT {
-    fn default() -> DebugMarkerMarkerInfoEXT {
-        DebugMarkerMarkerInfoEXT {
-            s_type: StructureType::DEBUG_MARKER_MARKER_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_marker_name: ::std::ptr::null(),
             color: unsafe { ::std::mem::zeroed() },
         }
     }
 }
+unsafe impl TaggedStructure for DebugMarkerMarkerInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_MARKER_MARKER_INFO_EXT;
+}
 impl DebugMarkerMarkerInfoEXT {
     pub fn builder<'a>() -> DebugMarkerMarkerInfoEXTBuilder<'a> {
         DebugMarkerMarkerInfoEXTBuilder {
-            inner: DebugMarkerMarkerInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11598,10 +12949,12 @@ impl<'a> ::std::ops::DerefMut for DebugMarkerMarkerInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> {
+    #[inline]
     pub fn marker_name(mut self, marker_name: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_marker_name = marker_name.as_ptr();
         self
     }
+    #[inline]
     pub fn color(mut self, color: [f32; 4]) -> Self {
         self.inner.color = color;
         self
@@ -11614,26 +12967,31 @@ impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDedicatedAllocationImageCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationImageCreateInfoNV.html>"]
 pub struct DedicatedAllocationImageCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub dedicated_allocation: Bool32,
 }
 impl ::std::default::Default for DedicatedAllocationImageCreateInfoNV {
-    fn default() -> DedicatedAllocationImageCreateInfoNV {
-        DedicatedAllocationImageCreateInfoNV {
-            s_type: StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             dedicated_allocation: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DedicatedAllocationImageCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV;
+}
 impl DedicatedAllocationImageCreateInfoNV {
     pub fn builder<'a>() -> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
         DedicatedAllocationImageCreateInfoNVBuilder {
-            inner: DedicatedAllocationImageCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11657,6 +13015,7 @@ impl<'a> ::std::ops::DerefMut for DedicatedAllocationImageCreateInfoNVBuilder<'a
     }
 }
 impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
         self.inner.dedicated_allocation = dedicated_allocation.into();
         self
@@ -11669,26 +13028,31 @@ impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDedicatedAllocationBufferCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationBufferCreateInfoNV.html>"]
 pub struct DedicatedAllocationBufferCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub dedicated_allocation: Bool32,
 }
 impl ::std::default::Default for DedicatedAllocationBufferCreateInfoNV {
-    fn default() -> DedicatedAllocationBufferCreateInfoNV {
-        DedicatedAllocationBufferCreateInfoNV {
-            s_type: StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             dedicated_allocation: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DedicatedAllocationBufferCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV;
+}
 impl DedicatedAllocationBufferCreateInfoNV {
     pub fn builder<'a>() -> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
         DedicatedAllocationBufferCreateInfoNVBuilder {
-            inner: DedicatedAllocationBufferCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11712,6 +13076,7 @@ impl<'a> ::std::ops::DerefMut for DedicatedAllocationBufferCreateInfoNVBuilder<'
     }
 }
 impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
         self.inner.dedicated_allocation = dedicated_allocation.into();
         self
@@ -11724,8 +13089,9 @@ impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html>"]
 pub struct DedicatedAllocationMemoryAllocateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -11733,19 +13099,24 @@ pub struct DedicatedAllocationMemoryAllocateInfoNV {
     pub buffer: Buffer,
 }
 impl ::std::default::Default for DedicatedAllocationMemoryAllocateInfoNV {
-    fn default() -> DedicatedAllocationMemoryAllocateInfoNV {
-        DedicatedAllocationMemoryAllocateInfoNV {
-            s_type: StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             image: Image::default(),
             buffer: Buffer::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DedicatedAllocationMemoryAllocateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV;
+}
 impl DedicatedAllocationMemoryAllocateInfoNV {
     pub fn builder<'a>() -> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
         DedicatedAllocationMemoryAllocateInfoNVBuilder {
-            inner: DedicatedAllocationMemoryAllocateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11769,10 +13140,12 @@ impl<'a> ::std::ops::DerefMut for DedicatedAllocationMemoryAllocateInfoNVBuilder
     }
 }
 impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
     }
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
@@ -11785,8 +13158,9 @@ impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalImageFormatPropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatPropertiesNV.html>"]
 pub struct ExternalImageFormatPropertiesNV {
     pub image_format_properties: ImageFormatProperties,
     pub external_memory_features: ExternalMemoryFeatureFlagsNV,
@@ -11796,7 +13170,7 @@ pub struct ExternalImageFormatPropertiesNV {
 impl ExternalImageFormatPropertiesNV {
     pub fn builder<'a>() -> ExternalImageFormatPropertiesNVBuilder<'a> {
         ExternalImageFormatPropertiesNVBuilder {
-            inner: ExternalImageFormatPropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11818,6 +13192,7 @@ impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesNVBuilder<'a> {
     }
 }
 impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
+    #[inline]
     pub fn image_format_properties(
         mut self,
         image_format_properties: ImageFormatProperties,
@@ -11825,6 +13200,7 @@ impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
         self.inner.image_format_properties = image_format_properties;
         self
     }
+    #[inline]
     pub fn external_memory_features(
         mut self,
         external_memory_features: ExternalMemoryFeatureFlagsNV,
@@ -11832,6 +13208,7 @@ impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
         self.inner.external_memory_features = external_memory_features;
         self
     }
+    #[inline]
     pub fn export_from_imported_handle_types(
         mut self,
         export_from_imported_handle_types: ExternalMemoryHandleTypeFlagsNV,
@@ -11839,6 +13216,7 @@ impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
         self
     }
+    #[inline]
     pub fn compatible_handle_types(
         mut self,
         compatible_handle_types: ExternalMemoryHandleTypeFlagsNV,
@@ -11854,26 +13232,31 @@ impl<'a> ExternalImageFormatPropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryImageCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfoNV.html>"]
 pub struct ExternalMemoryImageCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_types: ExternalMemoryHandleTypeFlagsNV,
 }
 impl ::std::default::Default for ExternalMemoryImageCreateInfoNV {
-    fn default() -> ExternalMemoryImageCreateInfoNV {
-        ExternalMemoryImageCreateInfoNV {
-            s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExternalMemoryImageCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV;
+}
 impl ExternalMemoryImageCreateInfoNV {
     pub fn builder<'a>() -> ExternalMemoryImageCreateInfoNVBuilder<'a> {
         ExternalMemoryImageCreateInfoNVBuilder {
-            inner: ExternalMemoryImageCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11897,6 +13280,7 @@ impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoNVBuilder<'a> {
     }
 }
 impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self {
         self.inner.handle_types = handle_types;
         self
@@ -11909,26 +13293,31 @@ impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryAllocateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfoNV.html>"]
 pub struct ExportMemoryAllocateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_types: ExternalMemoryHandleTypeFlagsNV,
 }
 impl ::std::default::Default for ExportMemoryAllocateInfoNV {
-    fn default() -> ExportMemoryAllocateInfoNV {
-        ExportMemoryAllocateInfoNV {
-            s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_types: ExternalMemoryHandleTypeFlagsNV::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExportMemoryAllocateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_ALLOCATE_INFO_NV;
+}
 impl ExportMemoryAllocateInfoNV {
     pub fn builder<'a>() -> ExportMemoryAllocateInfoNVBuilder<'a> {
         ExportMemoryAllocateInfoNVBuilder {
-            inner: ExportMemoryAllocateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -11952,6 +13341,7 @@ impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoNVBuilder<'a> {
     }
 }
 impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> {
+    #[inline]
     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlagsNV) -> Self {
         self.inner.handle_types = handle_types;
         self
@@ -11964,8 +13354,9 @@ impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryWin32HandleInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoNV.html>"]
 pub struct ImportMemoryWin32HandleInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -11973,19 +13364,23 @@ pub struct ImportMemoryWin32HandleInfoNV {
     pub handle: HANDLE,
 }
 impl ::std::default::Default for ImportMemoryWin32HandleInfoNV {
-    fn default() -> ImportMemoryWin32HandleInfoNV {
-        ImportMemoryWin32HandleInfoNV {
-            s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_type: ExternalMemoryHandleTypeFlagsNV::default(),
             handle: unsafe { ::std::mem::zeroed() },
         }
     }
 }
+unsafe impl TaggedStructure for ImportMemoryWin32HandleInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_NV;
+}
 impl ImportMemoryWin32HandleInfoNV {
     pub fn builder<'a>() -> ImportMemoryWin32HandleInfoNVBuilder<'a> {
         ImportMemoryWin32HandleInfoNVBuilder {
-            inner: ImportMemoryWin32HandleInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12009,10 +13404,12 @@ impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoNVBuilder<'a> {
     }
 }
 impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> {
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlagsNV) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn handle(mut self, handle: HANDLE) -> Self {
         self.inner.handle = handle;
         self
@@ -12025,8 +13422,9 @@ impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryWin32HandleInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoNV.html>"]
 pub struct ExportMemoryWin32HandleInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -12034,19 +13432,23 @@ pub struct ExportMemoryWin32HandleInfoNV {
     pub dw_access: DWORD,
 }
 impl ::std::default::Default for ExportMemoryWin32HandleInfoNV {
-    fn default() -> ExportMemoryWin32HandleInfoNV {
-        ExportMemoryWin32HandleInfoNV {
-            s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_attributes: ::std::ptr::null(),
             dw_access: DWORD::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExportMemoryWin32HandleInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_NV;
+}
 impl ExportMemoryWin32HandleInfoNV {
     pub fn builder<'a>() -> ExportMemoryWin32HandleInfoNVBuilder<'a> {
         ExportMemoryWin32HandleInfoNVBuilder {
-            inner: ExportMemoryWin32HandleInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12070,10 +13472,12 @@ impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoNVBuilder<'a> {
     }
 }
 impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> {
+    #[inline]
     pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
         self.inner.p_attributes = attributes;
         self
     }
+    #[inline]
     pub fn dw_access(mut self, dw_access: DWORD) -> Self {
         self.inner.dw_access = dw_access;
         self
@@ -12086,8 +13490,9 @@ impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html>"]
 pub struct Win32KeyedMutexAcquireReleaseInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -12100,9 +13505,10 @@ pub struct Win32KeyedMutexAcquireReleaseInfoNV {
     pub p_release_keys: *const u64,
 }
 impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV {
-    fn default() -> Win32KeyedMutexAcquireReleaseInfoNV {
-        Win32KeyedMutexAcquireReleaseInfoNV {
-            s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             acquire_count: u32::default(),
             p_acquire_syncs: ::std::ptr::null(),
@@ -12114,10 +13520,13 @@ impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for Win32KeyedMutexAcquireReleaseInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV;
+}
 impl Win32KeyedMutexAcquireReleaseInfoNV {
     pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
         Win32KeyedMutexAcquireReleaseInfoNVBuilder {
-            inner: Win32KeyedMutexAcquireReleaseInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12129,8 +13538,8 @@ pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
 }
 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoNV {}
-unsafe impl ExtendsSubmitInfo2KHR for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
-unsafe impl ExtendsSubmitInfo2KHR for Win32KeyedMutexAcquireReleaseInfoNV {}
+unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'_> {}
+unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoNV {}
 impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
     type Target = Win32KeyedMutexAcquireReleaseInfoNV;
     fn deref(&self) -> &Self::Target {
@@ -12143,26 +13552,31 @@ impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a>
     }
 }
 impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
+    #[inline]
     pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self {
         self.inner.acquire_count = acquire_syncs.len() as _;
         self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
         self
     }
+    #[inline]
     pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self {
         self.inner.acquire_count = acquire_keys.len() as _;
         self.inner.p_acquire_keys = acquire_keys.as_ptr();
         self
     }
+    #[inline]
     pub fn acquire_timeout_milliseconds(mut self, acquire_timeout_milliseconds: &'a [u32]) -> Self {
         self.inner.acquire_count = acquire_timeout_milliseconds.len() as _;
         self.inner.p_acquire_timeout_milliseconds = acquire_timeout_milliseconds.as_ptr();
         self
     }
+    #[inline]
     pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self {
         self.inner.release_count = release_syncs.len() as _;
         self.inner.p_release_syncs = release_syncs.as_ptr();
         self
     }
+    #[inline]
     pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self {
         self.inner.release_count = release_keys.len() as _;
         self.inner.p_release_keys = release_keys.as_ptr();
@@ -12176,26 +13590,32 @@ impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html>"]
 pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub device_generated_commands: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
-    fn default() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
-        PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             device_generated_commands: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV;
+}
 impl PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
         PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder {
-            inner: PhysicalDeviceDeviceGeneratedCommandsFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12224,6 +13644,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsFeaturesN
     }
 }
 impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn device_generated_commands(mut self, device_generated_commands: bool) -> Self {
         self.inner.device_generated_commands = device_generated_commands.into();
         self
@@ -12236,49 +13657,55 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDevicePrivateDataCreateInfoEXT.html>"]
-pub struct DevicePrivateDataCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDevicePrivateDataCreateInfo.html>"]
+pub struct DevicePrivateDataCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub private_data_slot_request_count: u32,
 }
-impl ::std::default::Default for DevicePrivateDataCreateInfoEXT {
-    fn default() -> DevicePrivateDataCreateInfoEXT {
-        DevicePrivateDataCreateInfoEXT {
-            s_type: StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO_EXT,
+impl ::std::default::Default for DevicePrivateDataCreateInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             private_data_slot_request_count: u32::default(),
         }
     }
 }
-impl DevicePrivateDataCreateInfoEXT {
-    pub fn builder<'a>() -> DevicePrivateDataCreateInfoEXTBuilder<'a> {
-        DevicePrivateDataCreateInfoEXTBuilder {
-            inner: DevicePrivateDataCreateInfoEXT::default(),
+unsafe impl TaggedStructure for DevicePrivateDataCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_PRIVATE_DATA_CREATE_INFO;
+}
+impl DevicePrivateDataCreateInfo {
+    pub fn builder<'a>() -> DevicePrivateDataCreateInfoBuilder<'a> {
+        DevicePrivateDataCreateInfoBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct DevicePrivateDataCreateInfoEXTBuilder<'a> {
-    inner: DevicePrivateDataCreateInfoEXT,
+pub struct DevicePrivateDataCreateInfoBuilder<'a> {
+    inner: DevicePrivateDataCreateInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoEXTBuilder<'_> {}
-unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoEXT {}
-impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoEXTBuilder<'a> {
-    type Target = DevicePrivateDataCreateInfoEXT;
+unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfoBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for DevicePrivateDataCreateInfo {}
+impl<'a> ::std::ops::Deref for DevicePrivateDataCreateInfoBuilder<'a> {
+    type Target = DevicePrivateDataCreateInfo;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for DevicePrivateDataCreateInfoBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> DevicePrivateDataCreateInfoEXTBuilder<'a> {
+impl<'a> DevicePrivateDataCreateInfoBuilder<'a> {
+    #[inline]
     pub fn private_data_slot_request_count(mut self, private_data_slot_request_count: u32) -> Self {
         self.inner.private_data_slot_request_count = private_data_slot_request_count;
         self
@@ -12286,109 +13713,121 @@ impl<'a> DevicePrivateDataCreateInfoEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> DevicePrivateDataCreateInfoEXT {
+    pub fn build(self) -> DevicePrivateDataCreateInfo {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPrivateDataSlotCreateInfoEXT.html>"]
-pub struct PrivateDataSlotCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrivateDataSlotCreateInfo.html>"]
+pub struct PrivateDataSlotCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub flags: PrivateDataSlotCreateFlagsEXT,
+    pub flags: PrivateDataSlotCreateFlags,
 }
-impl ::std::default::Default for PrivateDataSlotCreateInfoEXT {
-    fn default() -> PrivateDataSlotCreateInfoEXT {
-        PrivateDataSlotCreateInfoEXT {
-            s_type: StructureType::PRIVATE_DATA_SLOT_CREATE_INFO_EXT,
+impl ::std::default::Default for PrivateDataSlotCreateInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            flags: PrivateDataSlotCreateFlagsEXT::default(),
+            flags: PrivateDataSlotCreateFlags::default(),
         }
     }
 }
-impl PrivateDataSlotCreateInfoEXT {
-    pub fn builder<'a>() -> PrivateDataSlotCreateInfoEXTBuilder<'a> {
-        PrivateDataSlotCreateInfoEXTBuilder {
-            inner: PrivateDataSlotCreateInfoEXT::default(),
+unsafe impl TaggedStructure for PrivateDataSlotCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PRIVATE_DATA_SLOT_CREATE_INFO;
+}
+impl PrivateDataSlotCreateInfo {
+    pub fn builder<'a>() -> PrivateDataSlotCreateInfoBuilder<'a> {
+        PrivateDataSlotCreateInfoBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PrivateDataSlotCreateInfoEXTBuilder<'a> {
-    inner: PrivateDataSlotCreateInfoEXT,
+pub struct PrivateDataSlotCreateInfoBuilder<'a> {
+    inner: PrivateDataSlotCreateInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoEXTBuilder<'a> {
-    type Target = PrivateDataSlotCreateInfoEXT;
+impl<'a> ::std::ops::Deref for PrivateDataSlotCreateInfoBuilder<'a> {
+    type Target = PrivateDataSlotCreateInfo;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PrivateDataSlotCreateInfoBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PrivateDataSlotCreateInfoEXTBuilder<'a> {
-    pub fn flags(mut self, flags: PrivateDataSlotCreateFlagsEXT) -> Self {
+impl<'a> PrivateDataSlotCreateInfoBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: PrivateDataSlotCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PrivateDataSlotCreateInfoEXT {
+    pub fn build(self) -> PrivateDataSlotCreateInfo {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePrivateDataFeaturesEXT.html>"]
-pub struct PhysicalDevicePrivateDataFeaturesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrivateDataFeatures.html>"]
+pub struct PhysicalDevicePrivateDataFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub private_data: Bool32,
 }
-impl ::std::default::Default for PhysicalDevicePrivateDataFeaturesEXT {
-    fn default() -> PhysicalDevicePrivateDataFeaturesEXT {
-        PhysicalDevicePrivateDataFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT,
+impl ::std::default::Default for PhysicalDevicePrivateDataFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             private_data: Bool32::default(),
         }
     }
 }
-impl PhysicalDevicePrivateDataFeaturesEXT {
-    pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
-        PhysicalDevicePrivateDataFeaturesEXTBuilder {
-            inner: PhysicalDevicePrivateDataFeaturesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDevicePrivateDataFeatures {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
+}
+impl PhysicalDevicePrivateDataFeatures {
+    pub fn builder<'a>() -> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
+        PhysicalDevicePrivateDataFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
-    inner: PhysicalDevicePrivateDataFeaturesEXT,
+pub struct PhysicalDevicePrivateDataFeaturesBuilder<'a> {
+    inner: PhysicalDevicePrivateDataFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesEXTBuilder<'_> {}
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesEXT {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesEXTBuilder<'_> {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
-    type Target = PhysicalDevicePrivateDataFeaturesEXT;
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeaturesBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrivateDataFeatures {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrivateDataFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
+    type Target = PhysicalDevicePrivateDataFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePrivateDataFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
+impl<'a> PhysicalDevicePrivateDataFeaturesBuilder<'a> {
+    #[inline]
     pub fn private_data(mut self, private_data: bool) -> Self {
         self.inner.private_data = private_data.into();
         self
@@ -12396,13 +13835,14 @@ impl<'a> PhysicalDevicePrivateDataFeaturesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDevicePrivateDataFeaturesEXT {
+    pub fn build(self) -> PhysicalDevicePrivateDataFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html>"]
 pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -12417,9 +13857,10 @@ pub struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
     pub min_indirect_commands_buffer_offset_alignment: u32,
 }
 impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
-    fn default() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
-        PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_graphics_shader_group_count: u32::default(),
             max_indirect_sequence_count: u32::default(),
@@ -12433,10 +13874,14 @@ impl ::std::default::Default for PhysicalDeviceDeviceGeneratedCommandsProperties
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV;
+}
 impl PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
     pub fn builder<'a>() -> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
         PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder {
-            inner: PhysicalDeviceDeviceGeneratedCommandsPropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12463,14 +13908,17 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceGeneratedCommandsPropertie
     }
 }
 impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
+    #[inline]
     pub fn max_graphics_shader_group_count(mut self, max_graphics_shader_group_count: u32) -> Self {
         self.inner.max_graphics_shader_group_count = max_graphics_shader_group_count;
         self
     }
+    #[inline]
     pub fn max_indirect_sequence_count(mut self, max_indirect_sequence_count: u32) -> Self {
         self.inner.max_indirect_sequence_count = max_indirect_sequence_count;
         self
     }
+    #[inline]
     pub fn max_indirect_commands_token_count(
         mut self,
         max_indirect_commands_token_count: u32,
@@ -12478,6 +13926,7 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
         self.inner.max_indirect_commands_token_count = max_indirect_commands_token_count;
         self
     }
+    #[inline]
     pub fn max_indirect_commands_stream_count(
         mut self,
         max_indirect_commands_stream_count: u32,
@@ -12485,6 +13934,7 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
         self.inner.max_indirect_commands_stream_count = max_indirect_commands_stream_count;
         self
     }
+    #[inline]
     pub fn max_indirect_commands_token_offset(
         mut self,
         max_indirect_commands_token_offset: u32,
@@ -12492,6 +13942,7 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
         self.inner.max_indirect_commands_token_offset = max_indirect_commands_token_offset;
         self
     }
+    #[inline]
     pub fn max_indirect_commands_stream_stride(
         mut self,
         max_indirect_commands_stream_stride: u32,
@@ -12499,6 +13950,7 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
         self.inner.max_indirect_commands_stream_stride = max_indirect_commands_stream_stride;
         self
     }
+    #[inline]
     pub fn min_sequences_count_buffer_offset_alignment(
         mut self,
         min_sequences_count_buffer_offset_alignment: u32,
@@ -12507,6 +13959,7 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
             min_sequences_count_buffer_offset_alignment;
         self
     }
+    #[inline]
     pub fn min_sequences_index_buffer_offset_alignment(
         mut self,
         min_sequences_index_buffer_offset_alignment: u32,
@@ -12515,6 +13968,7 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
             min_sequences_index_buffer_offset_alignment;
         self
     }
+    #[inline]
     pub fn min_indirect_commands_buffer_offset_alignment(
         mut self,
         min_indirect_commands_buffer_offset_alignment: u32,
@@ -12531,26 +13985,31 @@ impl<'a> PhysicalDeviceDeviceGeneratedCommandsPropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html>"]
 pub struct PhysicalDeviceMultiDrawPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_multi_draw_count: u32,
 }
 impl ::std::default::Default for PhysicalDeviceMultiDrawPropertiesEXT {
-    fn default() -> PhysicalDeviceMultiDrawPropertiesEXT {
-        PhysicalDeviceMultiDrawPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_multi_draw_count: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMultiDrawPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT;
+}
 impl PhysicalDeviceMultiDrawPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
         PhysicalDeviceMultiDrawPropertiesEXTBuilder {
-            inner: PhysicalDeviceMultiDrawPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12574,6 +14033,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a
     }
 }
 impl<'a> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn max_multi_draw_count(mut self, max_multi_draw_count: u32) -> Self {
         self.inner.max_multi_draw_count = max_multi_draw_count;
         self
@@ -12586,8 +14046,9 @@ impl<'a> PhysicalDeviceMultiDrawPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsShaderGroupCreateInfoNV.html>"]
 pub struct GraphicsShaderGroupCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -12597,9 +14058,10 @@ pub struct GraphicsShaderGroupCreateInfoNV {
     pub p_tessellation_state: *const PipelineTessellationStateCreateInfo,
 }
 impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV {
-    fn default() -> GraphicsShaderGroupCreateInfoNV {
-        GraphicsShaderGroupCreateInfoNV {
-            s_type: StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             stage_count: u32::default(),
             p_stages: ::std::ptr::null(),
@@ -12608,10 +14070,13 @@ impl ::std::default::Default for GraphicsShaderGroupCreateInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for GraphicsShaderGroupCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_SHADER_GROUP_CREATE_INFO_NV;
+}
 impl GraphicsShaderGroupCreateInfoNV {
     pub fn builder<'a>() -> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
         GraphicsShaderGroupCreateInfoNVBuilder {
-            inner: GraphicsShaderGroupCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12633,11 +14098,13 @@ impl<'a> ::std::ops::DerefMut for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
     }
 }
 impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
         self.inner.stage_count = stages.len() as _;
         self.inner.p_stages = stages.as_ptr();
         self
     }
+    #[inline]
     pub fn vertex_input_state(
         mut self,
         vertex_input_state: &'a PipelineVertexInputStateCreateInfo,
@@ -12645,6 +14112,7 @@ impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
         self.inner.p_vertex_input_state = vertex_input_state;
         self
     }
+    #[inline]
     pub fn tessellation_state(
         mut self,
         tessellation_state: &'a PipelineTessellationStateCreateInfo,
@@ -12660,8 +14128,9 @@ impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html>"]
 pub struct GraphicsPipelineShaderGroupsCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -12671,9 +14140,10 @@ pub struct GraphicsPipelineShaderGroupsCreateInfoNV {
     pub p_pipelines: *const Pipeline,
 }
 impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV {
-    fn default() -> GraphicsPipelineShaderGroupsCreateInfoNV {
-        GraphicsPipelineShaderGroupsCreateInfoNV {
-            s_type: StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             group_count: u32::default(),
             p_groups: ::std::ptr::null(),
@@ -12682,10 +14152,14 @@ impl ::std::default::Default for GraphicsPipelineShaderGroupsCreateInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for GraphicsPipelineShaderGroupsCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV;
+}
 impl GraphicsPipelineShaderGroupsCreateInfoNV {
     pub fn builder<'a>() -> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
         GraphicsPipelineShaderGroupsCreateInfoNVBuilder {
-            inner: GraphicsPipelineShaderGroupsCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12712,11 +14186,13 @@ impl<'a> ::std::ops::DerefMut for GraphicsPipelineShaderGroupsCreateInfoNVBuilde
     }
 }
 impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn groups(mut self, groups: &'a [GraphicsShaderGroupCreateInfoNV]) -> Self {
         self.inner.group_count = groups.len() as _;
         self.inner.p_groups = groups.as_ptr();
         self
     }
+    #[inline]
     pub fn pipelines(mut self, pipelines: &'a [Pipeline]) -> Self {
         self.inner.pipeline_count = pipelines.len() as _;
         self.inner.p_pipelines = pipelines.as_ptr();
@@ -12730,15 +14206,16 @@ impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindShaderGroupIndirectCommandNV.html>"]
 pub struct BindShaderGroupIndirectCommandNV {
     pub group_index: u32,
 }
 impl BindShaderGroupIndirectCommandNV {
     pub fn builder<'a>() -> BindShaderGroupIndirectCommandNVBuilder<'a> {
         BindShaderGroupIndirectCommandNVBuilder {
-            inner: BindShaderGroupIndirectCommandNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12760,6 +14237,7 @@ impl<'a> ::std::ops::DerefMut for BindShaderGroupIndirectCommandNVBuilder<'a> {
     }
 }
 impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> {
+    #[inline]
     pub fn group_index(mut self, group_index: u32) -> Self {
         self.inner.group_index = group_index;
         self
@@ -12772,8 +14250,9 @@ impl<'a> BindShaderGroupIndirectCommandNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindIndexBufferIndirectCommandNV.html>"]
 pub struct BindIndexBufferIndirectCommandNV {
     pub buffer_address: DeviceAddress,
     pub size: u32,
@@ -12782,7 +14261,7 @@ pub struct BindIndexBufferIndirectCommandNV {
 impl BindIndexBufferIndirectCommandNV {
     pub fn builder<'a>() -> BindIndexBufferIndirectCommandNVBuilder<'a> {
         BindIndexBufferIndirectCommandNVBuilder {
-            inner: BindIndexBufferIndirectCommandNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12804,14 +14283,17 @@ impl<'a> ::std::ops::DerefMut for BindIndexBufferIndirectCommandNVBuilder<'a> {
     }
 }
 impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> {
+    #[inline]
     pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self {
         self.inner.buffer_address = buffer_address;
         self
     }
+    #[inline]
     pub fn size(mut self, size: u32) -> Self {
         self.inner.size = size;
         self
     }
+    #[inline]
     pub fn index_type(mut self, index_type: IndexType) -> Self {
         self.inner.index_type = index_type;
         self
@@ -12824,8 +14306,9 @@ impl<'a> BindIndexBufferIndirectCommandNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindVertexBufferIndirectCommandNV.html>"]
 pub struct BindVertexBufferIndirectCommandNV {
     pub buffer_address: DeviceAddress,
     pub size: u32,
@@ -12834,7 +14317,7 @@ pub struct BindVertexBufferIndirectCommandNV {
 impl BindVertexBufferIndirectCommandNV {
     pub fn builder<'a>() -> BindVertexBufferIndirectCommandNVBuilder<'a> {
         BindVertexBufferIndirectCommandNVBuilder {
-            inner: BindVertexBufferIndirectCommandNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12856,14 +14339,17 @@ impl<'a> ::std::ops::DerefMut for BindVertexBufferIndirectCommandNVBuilder<'a> {
     }
 }
 impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> {
+    #[inline]
     pub fn buffer_address(mut self, buffer_address: DeviceAddress) -> Self {
         self.inner.buffer_address = buffer_address;
         self
     }
+    #[inline]
     pub fn size(mut self, size: u32) -> Self {
         self.inner.size = size;
         self
     }
+    #[inline]
     pub fn stride(mut self, stride: u32) -> Self {
         self.inner.stride = stride;
         self
@@ -12876,15 +14362,16 @@ impl<'a> BindVertexBufferIndirectCommandNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSetStateFlagsIndirectCommandNV.html>"]
 pub struct SetStateFlagsIndirectCommandNV {
     pub data: u32,
 }
 impl SetStateFlagsIndirectCommandNV {
     pub fn builder<'a>() -> SetStateFlagsIndirectCommandNVBuilder<'a> {
         SetStateFlagsIndirectCommandNVBuilder {
-            inner: SetStateFlagsIndirectCommandNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12906,6 +14393,7 @@ impl<'a> ::std::ops::DerefMut for SetStateFlagsIndirectCommandNVBuilder<'a> {
     }
 }
 impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> {
+    #[inline]
     pub fn data(mut self, data: u32) -> Self {
         self.inner.data = data;
         self
@@ -12918,8 +14406,9 @@ impl<'a> SetStateFlagsIndirectCommandNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsStreamNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsStreamNV.html>"]
 pub struct IndirectCommandsStreamNV {
     pub buffer: Buffer,
     pub offset: DeviceSize,
@@ -12927,7 +14416,7 @@ pub struct IndirectCommandsStreamNV {
 impl IndirectCommandsStreamNV {
     pub fn builder<'a>() -> IndirectCommandsStreamNVBuilder<'a> {
         IndirectCommandsStreamNVBuilder {
-            inner: IndirectCommandsStreamNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -12949,10 +14438,12 @@ impl<'a> ::std::ops::DerefMut for IndirectCommandsStreamNVBuilder<'a> {
     }
 }
 impl<'a> IndirectCommandsStreamNVBuilder<'a> {
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
@@ -12965,8 +14456,9 @@ impl<'a> IndirectCommandsStreamNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutTokenNV.html>"]
 pub struct IndirectCommandsLayoutTokenNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -12985,9 +14477,10 @@ pub struct IndirectCommandsLayoutTokenNV {
     pub p_index_type_values: *const u32,
 }
 impl ::std::default::Default for IndirectCommandsLayoutTokenNV {
-    fn default() -> IndirectCommandsLayoutTokenNV {
-        IndirectCommandsLayoutTokenNV {
-            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             token_type: IndirectCommandsTokenTypeNV::default(),
             stream: u32::default(),
@@ -13005,10 +14498,13 @@ impl ::std::default::Default for IndirectCommandsLayoutTokenNV {
         }
     }
 }
+unsafe impl TaggedStructure for IndirectCommandsLayoutTokenNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::INDIRECT_COMMANDS_LAYOUT_TOKEN_NV;
+}
 impl IndirectCommandsLayoutTokenNV {
     pub fn builder<'a>() -> IndirectCommandsLayoutTokenNVBuilder<'a> {
         IndirectCommandsLayoutTokenNVBuilder {
-            inner: IndirectCommandsLayoutTokenNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13030,26 +14526,32 @@ impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutTokenNVBuilder<'a> {
     }
 }
 impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
+    #[inline]
     pub fn token_type(mut self, token_type: IndirectCommandsTokenTypeNV) -> Self {
         self.inner.token_type = token_type;
         self
     }
+    #[inline]
     pub fn stream(mut self, stream: u32) -> Self {
         self.inner.stream = stream;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: u32) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self {
         self.inner.vertex_binding_unit = vertex_binding_unit;
         self
     }
+    #[inline]
     pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self {
         self.inner.vertex_dynamic_stride = vertex_dynamic_stride.into();
         self
     }
+    #[inline]
     pub fn pushconstant_pipeline_layout(
         mut self,
         pushconstant_pipeline_layout: PipelineLayout,
@@ -13057,6 +14559,7 @@ impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
         self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout;
         self
     }
+    #[inline]
     pub fn pushconstant_shader_stage_flags(
         mut self,
         pushconstant_shader_stage_flags: ShaderStageFlags,
@@ -13064,23 +14567,28 @@ impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
         self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags;
         self
     }
+    #[inline]
     pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self {
         self.inner.pushconstant_offset = pushconstant_offset;
         self
     }
+    #[inline]
     pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self {
         self.inner.pushconstant_size = pushconstant_size;
         self
     }
+    #[inline]
     pub fn indirect_state_flags(mut self, indirect_state_flags: IndirectStateFlagsNV) -> Self {
         self.inner.indirect_state_flags = indirect_state_flags;
         self
     }
+    #[inline]
     pub fn index_types(mut self, index_types: &'a [IndexType]) -> Self {
         self.inner.index_type_count = index_types.len() as _;
         self.inner.p_index_types = index_types.as_ptr();
         self
     }
+    #[inline]
     pub fn index_type_values(mut self, index_type_values: &'a [u32]) -> Self {
         self.inner.index_type_count = index_type_values.len() as _;
         self.inner.p_index_type_values = index_type_values.as_ptr();
@@ -13094,8 +14602,9 @@ impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsLayoutCreateInfoNV.html>"]
 pub struct IndirectCommandsLayoutCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -13107,9 +14616,10 @@ pub struct IndirectCommandsLayoutCreateInfoNV {
     pub p_stream_strides: *const u32,
 }
 impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV {
-    fn default() -> IndirectCommandsLayoutCreateInfoNV {
-        IndirectCommandsLayoutCreateInfoNV {
-            s_type: StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: IndirectCommandsLayoutUsageFlagsNV::default(),
             pipeline_bind_point: PipelineBindPoint::default(),
@@ -13120,10 +14630,13 @@ impl ::std::default::Default for IndirectCommandsLayoutCreateInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for IndirectCommandsLayoutCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV;
+}
 impl IndirectCommandsLayoutCreateInfoNV {
     pub fn builder<'a>() -> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
         IndirectCommandsLayoutCreateInfoNVBuilder {
-            inner: IndirectCommandsLayoutCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13145,19 +14658,23 @@ impl<'a> ::std::ops::DerefMut for IndirectCommandsLayoutCreateInfoNVBuilder<'a>
     }
 }
 impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: IndirectCommandsLayoutUsageFlagsNV) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
         self.inner.pipeline_bind_point = pipeline_bind_point;
         self
     }
+    #[inline]
     pub fn tokens(mut self, tokens: &'a [IndirectCommandsLayoutTokenNV]) -> Self {
         self.inner.token_count = tokens.len() as _;
         self.inner.p_tokens = tokens.as_ptr();
         self
     }
+    #[inline]
     pub fn stream_strides(mut self, stream_strides: &'a [u32]) -> Self {
         self.inner.stream_count = stream_strides.len() as _;
         self.inner.p_stream_strides = stream_strides.as_ptr();
@@ -13171,8 +14688,9 @@ impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsInfoNV.html>"]
 pub struct GeneratedCommandsInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -13191,9 +14709,10 @@ pub struct GeneratedCommandsInfoNV {
     pub sequences_index_offset: DeviceSize,
 }
 impl ::std::default::Default for GeneratedCommandsInfoNV {
-    fn default() -> GeneratedCommandsInfoNV {
-        GeneratedCommandsInfoNV {
-            s_type: StructureType::GENERATED_COMMANDS_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             pipeline_bind_point: PipelineBindPoint::default(),
             pipeline: Pipeline::default(),
@@ -13211,10 +14730,13 @@ impl ::std::default::Default for GeneratedCommandsInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for GeneratedCommandsInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::GENERATED_COMMANDS_INFO_NV;
+}
 impl GeneratedCommandsInfoNV {
     pub fn builder<'a>() -> GeneratedCommandsInfoNVBuilder<'a> {
         GeneratedCommandsInfoNVBuilder {
-            inner: GeneratedCommandsInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13236,14 +14758,17 @@ impl<'a> ::std::ops::DerefMut for GeneratedCommandsInfoNVBuilder<'a> {
     }
 }
 impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
+    #[inline]
     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
         self.inner.pipeline_bind_point = pipeline_bind_point;
         self
     }
+    #[inline]
     pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
         self.inner.pipeline = pipeline;
         self
     }
+    #[inline]
     pub fn indirect_commands_layout(
         mut self,
         indirect_commands_layout: IndirectCommandsLayoutNV,
@@ -13251,39 +14776,48 @@ impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
         self.inner.indirect_commands_layout = indirect_commands_layout;
         self
     }
+    #[inline]
     pub fn streams(mut self, streams: &'a [IndirectCommandsStreamNV]) -> Self {
         self.inner.stream_count = streams.len() as _;
         self.inner.p_streams = streams.as_ptr();
         self
     }
+    #[inline]
     pub fn sequences_count(mut self, sequences_count: u32) -> Self {
         self.inner.sequences_count = sequences_count;
         self
     }
+    #[inline]
     pub fn preprocess_buffer(mut self, preprocess_buffer: Buffer) -> Self {
         self.inner.preprocess_buffer = preprocess_buffer;
         self
     }
+    #[inline]
     pub fn preprocess_offset(mut self, preprocess_offset: DeviceSize) -> Self {
         self.inner.preprocess_offset = preprocess_offset;
         self
     }
+    #[inline]
     pub fn preprocess_size(mut self, preprocess_size: DeviceSize) -> Self {
         self.inner.preprocess_size = preprocess_size;
         self
     }
+    #[inline]
     pub fn sequences_count_buffer(mut self, sequences_count_buffer: Buffer) -> Self {
         self.inner.sequences_count_buffer = sequences_count_buffer;
         self
     }
+    #[inline]
     pub fn sequences_count_offset(mut self, sequences_count_offset: DeviceSize) -> Self {
         self.inner.sequences_count_offset = sequences_count_offset;
         self
     }
+    #[inline]
     pub fn sequences_index_buffer(mut self, sequences_index_buffer: Buffer) -> Self {
         self.inner.sequences_index_buffer = sequences_index_buffer;
         self
     }
+    #[inline]
     pub fn sequences_index_offset(mut self, sequences_index_offset: DeviceSize) -> Self {
         self.inner.sequences_index_offset = sequences_index_offset;
         self
@@ -13296,8 +14830,9 @@ impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html>"]
 pub struct GeneratedCommandsMemoryRequirementsInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -13307,9 +14842,10 @@ pub struct GeneratedCommandsMemoryRequirementsInfoNV {
     pub max_sequences_count: u32,
 }
 impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV {
-    fn default() -> GeneratedCommandsMemoryRequirementsInfoNV {
-        GeneratedCommandsMemoryRequirementsInfoNV {
-            s_type: StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             pipeline_bind_point: PipelineBindPoint::default(),
             pipeline: Pipeline::default(),
@@ -13318,10 +14854,14 @@ impl ::std::default::Default for GeneratedCommandsMemoryRequirementsInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for GeneratedCommandsMemoryRequirementsInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV;
+}
 impl GeneratedCommandsMemoryRequirementsInfoNV {
     pub fn builder<'a>() -> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
         GeneratedCommandsMemoryRequirementsInfoNVBuilder {
-            inner: GeneratedCommandsMemoryRequirementsInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13343,14 +14883,17 @@ impl<'a> ::std::ops::DerefMut for GeneratedCommandsMemoryRequirementsInfoNVBuild
     }
 }
 impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
+    #[inline]
     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
         self.inner.pipeline_bind_point = pipeline_bind_point;
         self
     }
+    #[inline]
     pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
         self.inner.pipeline = pipeline;
         self
     }
+    #[inline]
     pub fn indirect_commands_layout(
         mut self,
         indirect_commands_layout: IndirectCommandsLayoutNV,
@@ -13358,6 +14901,7 @@ impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
         self.inner.indirect_commands_layout = indirect_commands_layout;
         self
     }
+    #[inline]
     pub fn max_sequences_count(mut self, max_sequences_count: u32) -> Self {
         self.inner.max_sequences_count = max_sequences_count;
         self
@@ -13370,26 +14914,31 @@ impl<'a> GeneratedCommandsMemoryRequirementsInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFeatures2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFeatures2.html>"]
 pub struct PhysicalDeviceFeatures2 {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub features: PhysicalDeviceFeatures,
 }
 impl ::std::default::Default for PhysicalDeviceFeatures2 {
-    fn default() -> PhysicalDeviceFeatures2 {
-        PhysicalDeviceFeatures2 {
-            s_type: StructureType::PHYSICAL_DEVICE_FEATURES_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             features: PhysicalDeviceFeatures::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFeatures2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FEATURES_2;
+}
 impl PhysicalDeviceFeatures2 {
     pub fn builder<'a>() -> PhysicalDeviceFeatures2Builder<'a> {
         PhysicalDeviceFeatures2Builder {
-            inner: PhysicalDeviceFeatures2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13414,6 +14963,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFeatures2Builder<'a> {
     }
 }
 impl<'a> PhysicalDeviceFeatures2Builder<'a> {
+    #[inline]
     pub fn features(mut self, features: PhysicalDeviceFeatures) -> Self {
         self.inner.features = features;
         self
@@ -13425,10 +14975,10 @@ impl<'a> PhysicalDeviceFeatures2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsPhysicalDeviceFeatures2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -13440,26 +14990,31 @@ impl<'a> PhysicalDeviceFeatures2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProperties2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProperties2.html>"]
 pub struct PhysicalDeviceProperties2 {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub properties: PhysicalDeviceProperties,
 }
 impl ::std::default::Default for PhysicalDeviceProperties2 {
-    fn default() -> PhysicalDeviceProperties2 {
-        PhysicalDeviceProperties2 {
-            s_type: StructureType::PHYSICAL_DEVICE_PROPERTIES_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             properties: PhysicalDeviceProperties::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceProperties2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PROPERTIES_2;
+}
 impl PhysicalDeviceProperties2 {
     pub fn builder<'a>() -> PhysicalDeviceProperties2Builder<'a> {
         PhysicalDeviceProperties2Builder {
-            inner: PhysicalDeviceProperties2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13482,6 +15037,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceProperties2Builder<'a> {
     }
 }
 impl<'a> PhysicalDeviceProperties2Builder<'a> {
+    #[inline]
     pub fn properties(mut self, properties: PhysicalDeviceProperties) -> Self {
         self.inner.properties = properties;
         self
@@ -13493,10 +15049,10 @@ impl<'a> PhysicalDeviceProperties2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsPhysicalDeviceProperties2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -13508,26 +15064,31 @@ impl<'a> PhysicalDeviceProperties2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormatProperties2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties2.html>"]
 pub struct FormatProperties2 {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub format_properties: FormatProperties,
 }
 impl ::std::default::Default for FormatProperties2 {
-    fn default() -> FormatProperties2 {
-        FormatProperties2 {
-            s_type: StructureType::FORMAT_PROPERTIES_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             format_properties: FormatProperties::default(),
         }
     }
 }
+unsafe impl TaggedStructure for FormatProperties2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_2;
+}
 impl FormatProperties2 {
     pub fn builder<'a>() -> FormatProperties2Builder<'a> {
         FormatProperties2Builder {
-            inner: FormatProperties2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13550,6 +15111,7 @@ impl<'a> ::std::ops::DerefMut for FormatProperties2Builder<'a> {
     }
 }
 impl<'a> FormatProperties2Builder<'a> {
+    #[inline]
     pub fn format_properties(mut self, format_properties: FormatProperties) -> Self {
         self.inner.format_properties = format_properties;
         self
@@ -13561,10 +15123,10 @@ impl<'a> FormatProperties2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsFormatProperties2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -13576,26 +15138,31 @@ impl<'a> FormatProperties2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatProperties2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatProperties2.html>"]
 pub struct ImageFormatProperties2 {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub image_format_properties: ImageFormatProperties,
 }
 impl ::std::default::Default for ImageFormatProperties2 {
-    fn default() -> ImageFormatProperties2 {
-        ImageFormatProperties2 {
-            s_type: StructureType::IMAGE_FORMAT_PROPERTIES_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             image_format_properties: ImageFormatProperties::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageFormatProperties2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_PROPERTIES_2;
+}
 impl ImageFormatProperties2 {
     pub fn builder<'a>() -> ImageFormatProperties2Builder<'a> {
         ImageFormatProperties2Builder {
-            inner: ImageFormatProperties2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13618,6 +15185,7 @@ impl<'a> ::std::ops::DerefMut for ImageFormatProperties2Builder<'a> {
     }
 }
 impl<'a> ImageFormatProperties2Builder<'a> {
+    #[inline]
     pub fn image_format_properties(
         mut self,
         image_format_properties: ImageFormatProperties,
@@ -13632,10 +15200,10 @@ impl<'a> ImageFormatProperties2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsImageFormatProperties2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -13647,8 +15215,9 @@ impl<'a> ImageFormatProperties2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageFormatInfo2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageFormatInfo2.html>"]
 pub struct PhysicalDeviceImageFormatInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -13659,9 +15228,10 @@ pub struct PhysicalDeviceImageFormatInfo2 {
     pub flags: ImageCreateFlags,
 }
 impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 {
-    fn default() -> PhysicalDeviceImageFormatInfo2 {
-        PhysicalDeviceImageFormatInfo2 {
-            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             format: Format::default(),
             ty: ImageType::default(),
@@ -13671,10 +15241,13 @@ impl ::std::default::Default for PhysicalDeviceImageFormatInfo2 {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceImageFormatInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
+}
 impl PhysicalDeviceImageFormatInfo2 {
     pub fn builder<'a>() -> PhysicalDeviceImageFormatInfo2Builder<'a> {
         PhysicalDeviceImageFormatInfo2Builder {
-            inner: PhysicalDeviceImageFormatInfo2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13697,22 +15270,27 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageFormatInfo2Builder<'a> {
     }
 }
 impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn ty(mut self, ty: ImageType) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn tiling(mut self, tiling: ImageTiling) -> Self {
         self.inner.tiling = tiling;
         self
     }
+    #[inline]
     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
         self.inner.usage = usage;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
         self.inner.flags = flags;
         self
@@ -13724,10 +15302,10 @@ impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsPhysicalDeviceImageFormatInfo2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -13739,26 +15317,31 @@ impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyProperties2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyProperties2.html>"]
 pub struct QueueFamilyProperties2 {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub queue_family_properties: QueueFamilyProperties,
 }
 impl ::std::default::Default for QueueFamilyProperties2 {
-    fn default() -> QueueFamilyProperties2 {
-        QueueFamilyProperties2 {
-            s_type: StructureType::QUEUE_FAMILY_PROPERTIES_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             queue_family_properties: QueueFamilyProperties::default(),
         }
     }
 }
+unsafe impl TaggedStructure for QueueFamilyProperties2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_PROPERTIES_2;
+}
 impl QueueFamilyProperties2 {
     pub fn builder<'a>() -> QueueFamilyProperties2Builder<'a> {
         QueueFamilyProperties2Builder {
-            inner: QueueFamilyProperties2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13781,6 +15364,7 @@ impl<'a> ::std::ops::DerefMut for QueueFamilyProperties2Builder<'a> {
     }
 }
 impl<'a> QueueFamilyProperties2Builder<'a> {
+    #[inline]
     pub fn queue_family_properties(
         mut self,
         queue_family_properties: QueueFamilyProperties,
@@ -13795,10 +15379,10 @@ impl<'a> QueueFamilyProperties2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsQueueFamilyProperties2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -13810,26 +15394,31 @@ impl<'a> QueueFamilyProperties2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryProperties2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryProperties2.html>"]
 pub struct PhysicalDeviceMemoryProperties2 {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub memory_properties: PhysicalDeviceMemoryProperties,
 }
 impl ::std::default::Default for PhysicalDeviceMemoryProperties2 {
-    fn default() -> PhysicalDeviceMemoryProperties2 {
-        PhysicalDeviceMemoryProperties2 {
-            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             memory_properties: PhysicalDeviceMemoryProperties::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMemoryProperties2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
+}
 impl PhysicalDeviceMemoryProperties2 {
     pub fn builder<'a>() -> PhysicalDeviceMemoryProperties2Builder<'a> {
         PhysicalDeviceMemoryProperties2Builder {
-            inner: PhysicalDeviceMemoryProperties2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13852,6 +15441,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryProperties2Builder<'a> {
     }
 }
 impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> {
+    #[inline]
     pub fn memory_properties(mut self, memory_properties: PhysicalDeviceMemoryProperties) -> Self {
         self.inner.memory_properties = memory_properties;
         self
@@ -13863,10 +15453,10 @@ impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsPhysicalDeviceMemoryProperties2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -13878,26 +15468,31 @@ impl<'a> PhysicalDeviceMemoryProperties2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageFormatProperties2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageFormatProperties2.html>"]
 pub struct SparseImageFormatProperties2 {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub properties: SparseImageFormatProperties,
 }
 impl ::std::default::Default for SparseImageFormatProperties2 {
-    fn default() -> SparseImageFormatProperties2 {
-        SparseImageFormatProperties2 {
-            s_type: StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             properties: SparseImageFormatProperties::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SparseImageFormatProperties2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::SPARSE_IMAGE_FORMAT_PROPERTIES_2;
+}
 impl SparseImageFormatProperties2 {
     pub fn builder<'a>() -> SparseImageFormatProperties2Builder<'a> {
         SparseImageFormatProperties2Builder {
-            inner: SparseImageFormatProperties2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13919,6 +15514,7 @@ impl<'a> ::std::ops::DerefMut for SparseImageFormatProperties2Builder<'a> {
     }
 }
 impl<'a> SparseImageFormatProperties2Builder<'a> {
+    #[inline]
     pub fn properties(mut self, properties: SparseImageFormatProperties) -> Self {
         self.inner.properties = properties;
         self
@@ -13931,8 +15527,9 @@ impl<'a> SparseImageFormatProperties2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html>"]
 pub struct PhysicalDeviceSparseImageFormatInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -13943,9 +15540,10 @@ pub struct PhysicalDeviceSparseImageFormatInfo2 {
     pub tiling: ImageTiling,
 }
 impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 {
-    fn default() -> PhysicalDeviceSparseImageFormatInfo2 {
-        PhysicalDeviceSparseImageFormatInfo2 {
-            s_type: StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             format: Format::default(),
             ty: ImageType::default(),
@@ -13955,10 +15553,13 @@ impl ::std::default::Default for PhysicalDeviceSparseImageFormatInfo2 {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceSparseImageFormatInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
+}
 impl PhysicalDeviceSparseImageFormatInfo2 {
     pub fn builder<'a>() -> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
         PhysicalDeviceSparseImageFormatInfo2Builder {
-            inner: PhysicalDeviceSparseImageFormatInfo2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -13980,22 +15581,27 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSparseImageFormatInfo2Builder<'a
     }
 }
 impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn ty(mut self, ty: ImageType) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn samples(mut self, samples: SampleCountFlags) -> Self {
         self.inner.samples = samples;
         self
     }
+    #[inline]
     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
         self.inner.usage = usage;
         self
     }
+    #[inline]
     pub fn tiling(mut self, tiling: ImageTiling) -> Self {
         self.inner.tiling = tiling;
         self
@@ -14008,26 +15614,32 @@ impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePushDescriptorPropertiesKHR.html>"]
 pub struct PhysicalDevicePushDescriptorPropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_push_descriptors: u32,
 }
 impl ::std::default::Default for PhysicalDevicePushDescriptorPropertiesKHR {
-    fn default() -> PhysicalDevicePushDescriptorPropertiesKHR {
-        PhysicalDevicePushDescriptorPropertiesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_push_descriptors: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePushDescriptorPropertiesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
+}
 impl PhysicalDevicePushDescriptorPropertiesKHR {
     pub fn builder<'a>() -> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
         PhysicalDevicePushDescriptorPropertiesKHRBuilder {
-            inner: PhysicalDevicePushDescriptorPropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14054,6 +15666,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePushDescriptorPropertiesKHRBuild
     }
 }
 impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn max_push_descriptors(mut self, max_push_descriptors: u32) -> Self {
         self.inner.max_push_descriptors = max_push_descriptors;
         self
@@ -14066,8 +15679,9 @@ impl<'a> PhysicalDevicePushDescriptorPropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConformanceVersion.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConformanceVersion.html>"]
 pub struct ConformanceVersion {
     pub major: u8,
     pub minor: u8,
@@ -14077,7 +15691,7 @@ pub struct ConformanceVersion {
 impl ConformanceVersion {
     pub fn builder<'a>() -> ConformanceVersionBuilder<'a> {
         ConformanceVersionBuilder {
-            inner: ConformanceVersion::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14099,18 +15713,22 @@ impl<'a> ::std::ops::DerefMut for ConformanceVersionBuilder<'a> {
     }
 }
 impl<'a> ConformanceVersionBuilder<'a> {
+    #[inline]
     pub fn major(mut self, major: u8) -> Self {
         self.inner.major = major;
         self
     }
+    #[inline]
     pub fn minor(mut self, minor: u8) -> Self {
         self.inner.minor = minor;
         self
     }
+    #[inline]
     pub fn subminor(mut self, subminor: u8) -> Self {
         self.inner.subminor = subminor;
         self
     }
+    #[inline]
     pub fn patch(mut self, patch: u8) -> Self {
         self.inner.patch = patch;
         self
@@ -14124,7 +15742,7 @@ impl<'a> ConformanceVersionBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDriverProperties.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDriverProperties.html>"]
 pub struct PhysicalDeviceDriverProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -14133,6 +15751,7 @@ pub struct PhysicalDeviceDriverProperties {
     pub driver_info: [c_char; MAX_DRIVER_INFO_SIZE],
     pub conformance_version: ConformanceVersion,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for PhysicalDeviceDriverProperties {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("PhysicalDeviceDriverProperties")
@@ -14140,19 +15759,20 @@ impl fmt::Debug for PhysicalDeviceDriverProperties {
             .field("p_next", &self.p_next)
             .field("driver_id", &self.driver_id)
             .field("driver_name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr())
             })
             .field("driver_info", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr())
             })
             .field("conformance_version", &self.conformance_version)
             .finish()
     }
 }
 impl ::std::default::Default for PhysicalDeviceDriverProperties {
-    fn default() -> PhysicalDeviceDriverProperties {
-        PhysicalDeviceDriverProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             driver_id: DriverId::default(),
             driver_name: unsafe { ::std::mem::zeroed() },
@@ -14161,10 +15781,13 @@ impl ::std::default::Default for PhysicalDeviceDriverProperties {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDriverProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRIVER_PROPERTIES;
+}
 impl PhysicalDeviceDriverProperties {
     pub fn builder<'a>() -> PhysicalDeviceDriverPropertiesBuilder<'a> {
         PhysicalDeviceDriverPropertiesBuilder {
-            inner: PhysicalDeviceDriverProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14188,18 +15811,22 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDriverPropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> {
+    #[inline]
     pub fn driver_id(mut self, driver_id: DriverId) -> Self {
         self.inner.driver_id = driver_id;
         self
     }
+    #[inline]
     pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self {
         self.inner.driver_name = driver_name;
         self
     }
+    #[inline]
     pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self {
         self.inner.driver_info = driver_info;
         self
     }
+    #[inline]
     pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
         self.inner.conformance_version = conformance_version;
         self
@@ -14212,8 +15839,9 @@ impl<'a> PhysicalDeviceDriverPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentRegionsKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionsKHR.html>"]
 pub struct PresentRegionsKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -14221,19 +15849,23 @@ pub struct PresentRegionsKHR {
     pub p_regions: *const PresentRegionKHR,
 }
 impl ::std::default::Default for PresentRegionsKHR {
-    fn default() -> PresentRegionsKHR {
-        PresentRegionsKHR {
-            s_type: StructureType::PRESENT_REGIONS_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             swapchain_count: u32::default(),
             p_regions: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for PresentRegionsKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_REGIONS_KHR;
+}
 impl PresentRegionsKHR {
     pub fn builder<'a>() -> PresentRegionsKHRBuilder<'a> {
         PresentRegionsKHRBuilder {
-            inner: PresentRegionsKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14257,6 +15889,7 @@ impl<'a> ::std::ops::DerefMut for PresentRegionsKHRBuilder<'a> {
     }
 }
 impl<'a> PresentRegionsKHRBuilder<'a> {
+    #[inline]
     pub fn regions(mut self, regions: &'a [PresentRegionKHR]) -> Self {
         self.inner.swapchain_count = regions.len() as _;
         self.inner.p_regions = regions.as_ptr();
@@ -14270,15 +15903,17 @@ impl<'a> PresentRegionsKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentRegionKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentRegionKHR.html>"]
 pub struct PresentRegionKHR {
     pub rectangle_count: u32,
     pub p_rectangles: *const RectLayerKHR,
 }
 impl ::std::default::Default for PresentRegionKHR {
-    fn default() -> PresentRegionKHR {
-        PresentRegionKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
             rectangle_count: u32::default(),
             p_rectangles: ::std::ptr::null(),
         }
@@ -14287,7 +15922,7 @@ impl ::std::default::Default for PresentRegionKHR {
 impl PresentRegionKHR {
     pub fn builder<'a>() -> PresentRegionKHRBuilder<'a> {
         PresentRegionKHRBuilder {
-            inner: PresentRegionKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14309,6 +15944,7 @@ impl<'a> ::std::ops::DerefMut for PresentRegionKHRBuilder<'a> {
     }
 }
 impl<'a> PresentRegionKHRBuilder<'a> {
+    #[inline]
     pub fn rectangles(mut self, rectangles: &'a [RectLayerKHR]) -> Self {
         self.inner.rectangle_count = rectangles.len() as _;
         self.inner.p_rectangles = rectangles.as_ptr();
@@ -14322,8 +15958,9 @@ impl<'a> PresentRegionKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRectLayerKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRectLayerKHR.html>"]
 pub struct RectLayerKHR {
     pub offset: Offset2D,
     pub extent: Extent2D,
@@ -14332,7 +15969,7 @@ pub struct RectLayerKHR {
 impl RectLayerKHR {
     pub fn builder<'a>() -> RectLayerKHRBuilder<'a> {
         RectLayerKHRBuilder {
-            inner: RectLayerKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14354,14 +15991,17 @@ impl<'a> ::std::ops::DerefMut for RectLayerKHRBuilder<'a> {
     }
 }
 impl<'a> RectLayerKHRBuilder<'a> {
+    #[inline]
     pub fn offset(mut self, offset: Offset2D) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn extent(mut self, extent: Extent2D) -> Self {
         self.inner.extent = extent;
         self
     }
+    #[inline]
     pub fn layer(mut self, layer: u32) -> Self {
         self.inner.layer = layer;
         self
@@ -14374,8 +16014,9 @@ impl<'a> RectLayerKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVariablePointersFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVariablePointersFeatures.html>"]
 pub struct PhysicalDeviceVariablePointersFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -14383,19 +16024,23 @@ pub struct PhysicalDeviceVariablePointersFeatures {
     pub variable_pointers: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceVariablePointersFeatures {
-    fn default() -> PhysicalDeviceVariablePointersFeatures {
-        PhysicalDeviceVariablePointersFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             variable_pointers_storage_buffer: Bool32::default(),
             variable_pointers: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVariablePointersFeatures {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+}
 impl PhysicalDeviceVariablePointersFeatures {
     pub fn builder<'a>() -> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
         PhysicalDeviceVariablePointersFeaturesBuilder {
-            inner: PhysicalDeviceVariablePointersFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14421,6 +16066,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVariablePointersFeaturesBuilder<
     }
 }
 impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
+    #[inline]
     pub fn variable_pointers_storage_buffer(
         mut self,
         variable_pointers_storage_buffer: bool,
@@ -14428,6 +16074,7 @@ impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
         self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
         self
     }
+    #[inline]
     pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
         self.inner.variable_pointers = variable_pointers.into();
         self
@@ -14440,8 +16087,9 @@ impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryProperties.html>"]
 pub struct ExternalMemoryProperties {
     pub external_memory_features: ExternalMemoryFeatureFlags,
     pub export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
@@ -14450,7 +16098,7 @@ pub struct ExternalMemoryProperties {
 impl ExternalMemoryProperties {
     pub fn builder<'a>() -> ExternalMemoryPropertiesBuilder<'a> {
         ExternalMemoryPropertiesBuilder {
-            inner: ExternalMemoryProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14472,6 +16120,7 @@ impl<'a> ::std::ops::DerefMut for ExternalMemoryPropertiesBuilder<'a> {
     }
 }
 impl<'a> ExternalMemoryPropertiesBuilder<'a> {
+    #[inline]
     pub fn external_memory_features(
         mut self,
         external_memory_features: ExternalMemoryFeatureFlags,
@@ -14479,6 +16128,7 @@ impl<'a> ExternalMemoryPropertiesBuilder<'a> {
         self.inner.external_memory_features = external_memory_features;
         self
     }
+    #[inline]
     pub fn export_from_imported_handle_types(
         mut self,
         export_from_imported_handle_types: ExternalMemoryHandleTypeFlags,
@@ -14486,6 +16136,7 @@ impl<'a> ExternalMemoryPropertiesBuilder<'a> {
         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
         self
     }
+    #[inline]
     pub fn compatible_handle_types(
         mut self,
         compatible_handle_types: ExternalMemoryHandleTypeFlags,
@@ -14501,26 +16152,31 @@ impl<'a> ExternalMemoryPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalImageFormatInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalImageFormatInfo.html>"]
 pub struct PhysicalDeviceExternalImageFormatInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_type: ExternalMemoryHandleTypeFlags,
 }
 impl ::std::default::Default for PhysicalDeviceExternalImageFormatInfo {
-    fn default() -> PhysicalDeviceExternalImageFormatInfo {
-        PhysicalDeviceExternalImageFormatInfo {
-            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_type: ExternalMemoryHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceExternalImageFormatInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
+}
 impl PhysicalDeviceExternalImageFormatInfo {
     pub fn builder<'a>() -> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
         PhysicalDeviceExternalImageFormatInfoBuilder {
-            inner: PhysicalDeviceExternalImageFormatInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14547,6 +16203,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalImageFormatInfoBuilder<'
     }
 }
 impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -14559,26 +16216,31 @@ impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalImageFormatProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalImageFormatProperties.html>"]
 pub struct ExternalImageFormatProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub external_memory_properties: ExternalMemoryProperties,
 }
 impl ::std::default::Default for ExternalImageFormatProperties {
-    fn default() -> ExternalImageFormatProperties {
-        ExternalImageFormatProperties {
-            s_type: StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             external_memory_properties: ExternalMemoryProperties::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExternalImageFormatProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_IMAGE_FORMAT_PROPERTIES;
+}
 impl ExternalImageFormatProperties {
     pub fn builder<'a>() -> ExternalImageFormatPropertiesBuilder<'a> {
         ExternalImageFormatPropertiesBuilder {
-            inner: ExternalImageFormatProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14602,6 +16264,7 @@ impl<'a> ::std::ops::DerefMut for ExternalImageFormatPropertiesBuilder<'a> {
     }
 }
 impl<'a> ExternalImageFormatPropertiesBuilder<'a> {
+    #[inline]
     pub fn external_memory_properties(
         mut self,
         external_memory_properties: ExternalMemoryProperties,
@@ -14617,8 +16280,9 @@ impl<'a> ExternalImageFormatPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalBufferInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalBufferInfo.html>"]
 pub struct PhysicalDeviceExternalBufferInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -14627,9 +16291,10 @@ pub struct PhysicalDeviceExternalBufferInfo {
     pub handle_type: ExternalMemoryHandleTypeFlags,
 }
 impl ::std::default::Default for PhysicalDeviceExternalBufferInfo {
-    fn default() -> PhysicalDeviceExternalBufferInfo {
-        PhysicalDeviceExternalBufferInfo {
-            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: BufferCreateFlags::default(),
             usage: BufferUsageFlags::default(),
@@ -14637,10 +16302,13 @@ impl ::std::default::Default for PhysicalDeviceExternalBufferInfo {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceExternalBufferInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
+}
 impl PhysicalDeviceExternalBufferInfo {
     pub fn builder<'a>() -> PhysicalDeviceExternalBufferInfoBuilder<'a> {
         PhysicalDeviceExternalBufferInfoBuilder {
-            inner: PhysicalDeviceExternalBufferInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14662,14 +16330,17 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalBufferInfoBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: BufferCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
         self.inner.usage = usage;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -14682,26 +16353,31 @@ impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalBufferProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalBufferProperties.html>"]
 pub struct ExternalBufferProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub external_memory_properties: ExternalMemoryProperties,
 }
 impl ::std::default::Default for ExternalBufferProperties {
-    fn default() -> ExternalBufferProperties {
-        ExternalBufferProperties {
-            s_type: StructureType::EXTERNAL_BUFFER_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             external_memory_properties: ExternalMemoryProperties::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExternalBufferProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_BUFFER_PROPERTIES;
+}
 impl ExternalBufferProperties {
     pub fn builder<'a>() -> ExternalBufferPropertiesBuilder<'a> {
         ExternalBufferPropertiesBuilder {
-            inner: ExternalBufferProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14723,6 +16399,7 @@ impl<'a> ::std::ops::DerefMut for ExternalBufferPropertiesBuilder<'a> {
     }
 }
 impl<'a> ExternalBufferPropertiesBuilder<'a> {
+    #[inline]
     pub fn external_memory_properties(
         mut self,
         external_memory_properties: ExternalMemoryProperties,
@@ -14738,8 +16415,9 @@ impl<'a> ExternalBufferPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceIDProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIDProperties.html>"]
 pub struct PhysicalDeviceIDProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -14750,9 +16428,10 @@ pub struct PhysicalDeviceIDProperties {
     pub device_luid_valid: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceIDProperties {
-    fn default() -> PhysicalDeviceIDProperties {
-        PhysicalDeviceIDProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_ID_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             device_uuid: unsafe { ::std::mem::zeroed() },
             driver_uuid: unsafe { ::std::mem::zeroed() },
@@ -14762,10 +16441,13 @@ impl ::std::default::Default for PhysicalDeviceIDProperties {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceIDProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ID_PROPERTIES;
+}
 impl PhysicalDeviceIDProperties {
     pub fn builder<'a>() -> PhysicalDeviceIDPropertiesBuilder<'a> {
         PhysicalDeviceIDPropertiesBuilder {
-            inner: PhysicalDeviceIDProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14789,22 +16471,27 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceIDPropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> {
+    #[inline]
     pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self {
         self.inner.device_uuid = device_uuid;
         self
     }
+    #[inline]
     pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self {
         self.inner.driver_uuid = driver_uuid;
         self
     }
+    #[inline]
     pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self {
         self.inner.device_luid = device_luid;
         self
     }
+    #[inline]
     pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
         self.inner.device_node_mask = device_node_mask;
         self
     }
+    #[inline]
     pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
         self.inner.device_luid_valid = device_luid_valid.into();
         self
@@ -14817,26 +16504,31 @@ impl<'a> PhysicalDeviceIDPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryImageCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryImageCreateInfo.html>"]
 pub struct ExternalMemoryImageCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_types: ExternalMemoryHandleTypeFlags,
 }
 impl ::std::default::Default for ExternalMemoryImageCreateInfo {
-    fn default() -> ExternalMemoryImageCreateInfo {
-        ExternalMemoryImageCreateInfo {
-            s_type: StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_types: ExternalMemoryHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExternalMemoryImageCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
+}
 impl ExternalMemoryImageCreateInfo {
     pub fn builder<'a>() -> ExternalMemoryImageCreateInfoBuilder<'a> {
         ExternalMemoryImageCreateInfoBuilder {
-            inner: ExternalMemoryImageCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14860,6 +16552,7 @@ impl<'a> ::std::ops::DerefMut for ExternalMemoryImageCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> {
+    #[inline]
     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_types = handle_types;
         self
@@ -14872,26 +16565,31 @@ impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalMemoryBufferCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalMemoryBufferCreateInfo.html>"]
 pub struct ExternalMemoryBufferCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_types: ExternalMemoryHandleTypeFlags,
 }
 impl ::std::default::Default for ExternalMemoryBufferCreateInfo {
-    fn default() -> ExternalMemoryBufferCreateInfo {
-        ExternalMemoryBufferCreateInfo {
-            s_type: StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_types: ExternalMemoryHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExternalMemoryBufferCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
+}
 impl ExternalMemoryBufferCreateInfo {
     pub fn builder<'a>() -> ExternalMemoryBufferCreateInfoBuilder<'a> {
         ExternalMemoryBufferCreateInfoBuilder {
-            inner: ExternalMemoryBufferCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14915,6 +16613,7 @@ impl<'a> ::std::ops::DerefMut for ExternalMemoryBufferCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> {
+    #[inline]
     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_types = handle_types;
         self
@@ -14927,26 +16626,31 @@ impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryAllocateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryAllocateInfo.html>"]
 pub struct ExportMemoryAllocateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_types: ExternalMemoryHandleTypeFlags,
 }
 impl ::std::default::Default for ExportMemoryAllocateInfo {
-    fn default() -> ExportMemoryAllocateInfo {
-        ExportMemoryAllocateInfo {
-            s_type: StructureType::EXPORT_MEMORY_ALLOCATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_types: ExternalMemoryHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExportMemoryAllocateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_ALLOCATE_INFO;
+}
 impl ExportMemoryAllocateInfo {
     pub fn builder<'a>() -> ExportMemoryAllocateInfoBuilder<'a> {
         ExportMemoryAllocateInfoBuilder {
-            inner: ExportMemoryAllocateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -14970,6 +16674,7 @@ impl<'a> ::std::ops::DerefMut for ExportMemoryAllocateInfoBuilder<'a> {
     }
 }
 impl<'a> ExportMemoryAllocateInfoBuilder<'a> {
+    #[inline]
     pub fn handle_types(mut self, handle_types: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_types = handle_types;
         self
@@ -14982,8 +16687,9 @@ impl<'a> ExportMemoryAllocateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryWin32HandleInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryWin32HandleInfoKHR.html>"]
 pub struct ImportMemoryWin32HandleInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -14992,9 +16698,10 @@ pub struct ImportMemoryWin32HandleInfoKHR {
     pub name: LPCWSTR,
 }
 impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR {
-    fn default() -> ImportMemoryWin32HandleInfoKHR {
-        ImportMemoryWin32HandleInfoKHR {
-            s_type: StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_type: ExternalMemoryHandleTypeFlags::default(),
             handle: unsafe { ::std::mem::zeroed() },
@@ -15002,10 +16709,13 @@ impl ::std::default::Default for ImportMemoryWin32HandleInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for ImportMemoryWin32HandleInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
+}
 impl ImportMemoryWin32HandleInfoKHR {
     pub fn builder<'a>() -> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
         ImportMemoryWin32HandleInfoKHRBuilder {
-            inner: ImportMemoryWin32HandleInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15029,14 +16739,17 @@ impl<'a> ::std::ops::DerefMut for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn handle(mut self, handle: HANDLE) -> Self {
         self.inner.handle = handle;
         self
     }
+    #[inline]
     pub fn name(mut self, name: LPCWSTR) -> Self {
         self.inner.name = name;
         self
@@ -15049,8 +16762,9 @@ impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportMemoryWin32HandleInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMemoryWin32HandleInfoKHR.html>"]
 pub struct ExportMemoryWin32HandleInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -15059,9 +16773,10 @@ pub struct ExportMemoryWin32HandleInfoKHR {
     pub name: LPCWSTR,
 }
 impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR {
-    fn default() -> ExportMemoryWin32HandleInfoKHR {
-        ExportMemoryWin32HandleInfoKHR {
-            s_type: StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_attributes: ::std::ptr::null(),
             dw_access: DWORD::default(),
@@ -15069,10 +16784,13 @@ impl ::std::default::Default for ExportMemoryWin32HandleInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for ExportMemoryWin32HandleInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
+}
 impl ExportMemoryWin32HandleInfoKHR {
     pub fn builder<'a>() -> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
         ExportMemoryWin32HandleInfoKHRBuilder {
-            inner: ExportMemoryWin32HandleInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15096,14 +16814,17 @@ impl<'a> ::std::ops::DerefMut for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
+    #[inline]
     pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
         self.inner.p_attributes = attributes;
         self
     }
+    #[inline]
     pub fn dw_access(mut self, dw_access: DWORD) -> Self {
         self.inner.dw_access = dw_access;
         self
     }
+    #[inline]
     pub fn name(mut self, name: LPCWSTR) -> Self {
         self.inner.name = name;
         self
@@ -15116,8 +16837,9 @@ impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryZirconHandleInfoFUCHSIA.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryZirconHandleInfoFUCHSIA.html>"]
 pub struct ImportMemoryZirconHandleInfoFUCHSIA {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -15125,19 +16847,23 @@ pub struct ImportMemoryZirconHandleInfoFUCHSIA {
     pub handle: zx_handle_t,
 }
 impl ::std::default::Default for ImportMemoryZirconHandleInfoFUCHSIA {
-    fn default() -> ImportMemoryZirconHandleInfoFUCHSIA {
-        ImportMemoryZirconHandleInfoFUCHSIA {
-            s_type: StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_type: ExternalMemoryHandleTypeFlags::default(),
             handle: zx_handle_t::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImportMemoryZirconHandleInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA;
+}
 impl ImportMemoryZirconHandleInfoFUCHSIA {
     pub fn builder<'a>() -> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
         ImportMemoryZirconHandleInfoFUCHSIABuilder {
-            inner: ImportMemoryZirconHandleInfoFUCHSIA::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15161,10 +16887,12 @@ impl<'a> ::std::ops::DerefMut for ImportMemoryZirconHandleInfoFUCHSIABuilder<'a>
     }
 }
 impl<'a> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn handle(mut self, handle: zx_handle_t) -> Self {
         self.inner.handle = handle;
         self
@@ -15177,26 +16905,31 @@ impl<'a> ImportMemoryZirconHandleInfoFUCHSIABuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryZirconHandlePropertiesFUCHSIA.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryZirconHandlePropertiesFUCHSIA.html>"]
 pub struct MemoryZirconHandlePropertiesFUCHSIA {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub memory_type_bits: u32,
 }
 impl ::std::default::Default for MemoryZirconHandlePropertiesFUCHSIA {
-    fn default() -> MemoryZirconHandlePropertiesFUCHSIA {
-        MemoryZirconHandlePropertiesFUCHSIA {
-            s_type: StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             memory_type_bits: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryZirconHandlePropertiesFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA;
+}
 impl MemoryZirconHandlePropertiesFUCHSIA {
     pub fn builder<'a>() -> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
         MemoryZirconHandlePropertiesFUCHSIABuilder {
-            inner: MemoryZirconHandlePropertiesFUCHSIA::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15218,6 +16951,7 @@ impl<'a> ::std::ops::DerefMut for MemoryZirconHandlePropertiesFUCHSIABuilder<'a>
     }
 }
 impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
+    #[inline]
     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
         self.inner.memory_type_bits = memory_type_bits;
         self
@@ -15230,8 +16964,9 @@ impl<'a> MemoryZirconHandlePropertiesFUCHSIABuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetZirconHandleInfoFUCHSIA.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetZirconHandleInfoFUCHSIA.html>"]
 pub struct MemoryGetZirconHandleInfoFUCHSIA {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -15239,19 +16974,23 @@ pub struct MemoryGetZirconHandleInfoFUCHSIA {
     pub handle_type: ExternalMemoryHandleTypeFlags,
 }
 impl ::std::default::Default for MemoryGetZirconHandleInfoFUCHSIA {
-    fn default() -> MemoryGetZirconHandleInfoFUCHSIA {
-        MemoryGetZirconHandleInfoFUCHSIA {
-            s_type: StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             memory: DeviceMemory::default(),
             handle_type: ExternalMemoryHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryGetZirconHandleInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA;
+}
 impl MemoryGetZirconHandleInfoFUCHSIA {
     pub fn builder<'a>() -> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
         MemoryGetZirconHandleInfoFUCHSIABuilder {
-            inner: MemoryGetZirconHandleInfoFUCHSIA::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15273,10 +17012,12 @@ impl<'a> ::std::ops::DerefMut for MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
     }
 }
 impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -15289,26 +17030,31 @@ impl<'a> MemoryGetZirconHandleInfoFUCHSIABuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryWin32HandlePropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryWin32HandlePropertiesKHR.html>"]
 pub struct MemoryWin32HandlePropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub memory_type_bits: u32,
 }
 impl ::std::default::Default for MemoryWin32HandlePropertiesKHR {
-    fn default() -> MemoryWin32HandlePropertiesKHR {
-        MemoryWin32HandlePropertiesKHR {
-            s_type: StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             memory_type_bits: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryWin32HandlePropertiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_WIN32_HANDLE_PROPERTIES_KHR;
+}
 impl MemoryWin32HandlePropertiesKHR {
     pub fn builder<'a>() -> MemoryWin32HandlePropertiesKHRBuilder<'a> {
         MemoryWin32HandlePropertiesKHRBuilder {
-            inner: MemoryWin32HandlePropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15330,6 +17076,7 @@ impl<'a> ::std::ops::DerefMut for MemoryWin32HandlePropertiesKHRBuilder<'a> {
     }
 }
 impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
         self.inner.memory_type_bits = memory_type_bits;
         self
@@ -15342,8 +17089,9 @@ impl<'a> MemoryWin32HandlePropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetWin32HandleInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetWin32HandleInfoKHR.html>"]
 pub struct MemoryGetWin32HandleInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -15351,19 +17099,23 @@ pub struct MemoryGetWin32HandleInfoKHR {
     pub handle_type: ExternalMemoryHandleTypeFlags,
 }
 impl ::std::default::Default for MemoryGetWin32HandleInfoKHR {
-    fn default() -> MemoryGetWin32HandleInfoKHR {
-        MemoryGetWin32HandleInfoKHR {
-            s_type: StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             memory: DeviceMemory::default(),
             handle_type: ExternalMemoryHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryGetWin32HandleInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_WIN32_HANDLE_INFO_KHR;
+}
 impl MemoryGetWin32HandleInfoKHR {
     pub fn builder<'a>() -> MemoryGetWin32HandleInfoKHRBuilder<'a> {
         MemoryGetWin32HandleInfoKHRBuilder {
-            inner: MemoryGetWin32HandleInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15385,10 +17137,12 @@ impl<'a> ::std::ops::DerefMut for MemoryGetWin32HandleInfoKHRBuilder<'a> {
     }
 }
 impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> {
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -15401,8 +17155,9 @@ impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryFdInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryFdInfoKHR.html>"]
 pub struct ImportMemoryFdInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -15410,19 +17165,23 @@ pub struct ImportMemoryFdInfoKHR {
     pub fd: c_int,
 }
 impl ::std::default::Default for ImportMemoryFdInfoKHR {
-    fn default() -> ImportMemoryFdInfoKHR {
-        ImportMemoryFdInfoKHR {
-            s_type: StructureType::IMPORT_MEMORY_FD_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_type: ExternalMemoryHandleTypeFlags::default(),
             fd: c_int::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImportMemoryFdInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_FD_INFO_KHR;
+}
 impl ImportMemoryFdInfoKHR {
     pub fn builder<'a>() -> ImportMemoryFdInfoKHRBuilder<'a> {
         ImportMemoryFdInfoKHRBuilder {
-            inner: ImportMemoryFdInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15446,10 +17205,12 @@ impl<'a> ::std::ops::DerefMut for ImportMemoryFdInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ImportMemoryFdInfoKHRBuilder<'a> {
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn fd(mut self, fd: c_int) -> Self {
         self.inner.fd = fd;
         self
@@ -15462,26 +17223,31 @@ impl<'a> ImportMemoryFdInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryFdPropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryFdPropertiesKHR.html>"]
 pub struct MemoryFdPropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub memory_type_bits: u32,
 }
 impl ::std::default::Default for MemoryFdPropertiesKHR {
-    fn default() -> MemoryFdPropertiesKHR {
-        MemoryFdPropertiesKHR {
-            s_type: StructureType::MEMORY_FD_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             memory_type_bits: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryFdPropertiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_FD_PROPERTIES_KHR;
+}
 impl MemoryFdPropertiesKHR {
     pub fn builder<'a>() -> MemoryFdPropertiesKHRBuilder<'a> {
         MemoryFdPropertiesKHRBuilder {
-            inner: MemoryFdPropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15503,6 +17269,7 @@ impl<'a> ::std::ops::DerefMut for MemoryFdPropertiesKHRBuilder<'a> {
     }
 }
 impl<'a> MemoryFdPropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
         self.inner.memory_type_bits = memory_type_bits;
         self
@@ -15515,8 +17282,9 @@ impl<'a> MemoryFdPropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetFdInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetFdInfoKHR.html>"]
 pub struct MemoryGetFdInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -15524,19 +17292,23 @@ pub struct MemoryGetFdInfoKHR {
     pub handle_type: ExternalMemoryHandleTypeFlags,
 }
 impl ::std::default::Default for MemoryGetFdInfoKHR {
-    fn default() -> MemoryGetFdInfoKHR {
-        MemoryGetFdInfoKHR {
-            s_type: StructureType::MEMORY_GET_FD_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             memory: DeviceMemory::default(),
             handle_type: ExternalMemoryHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryGetFdInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_FD_INFO_KHR;
+}
 impl MemoryGetFdInfoKHR {
     pub fn builder<'a>() -> MemoryGetFdInfoKHRBuilder<'a> {
         MemoryGetFdInfoKHRBuilder {
-            inner: MemoryGetFdInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15558,10 +17330,12 @@ impl<'a> ::std::ops::DerefMut for MemoryGetFdInfoKHRBuilder<'a> {
     }
 }
 impl<'a> MemoryGetFdInfoKHRBuilder<'a> {
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -15574,8 +17348,9 @@ impl<'a> MemoryGetFdInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html>"]
 pub struct Win32KeyedMutexAcquireReleaseInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -15588,9 +17363,10 @@ pub struct Win32KeyedMutexAcquireReleaseInfoKHR {
     pub p_release_keys: *const u64,
 }
 impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR {
-    fn default() -> Win32KeyedMutexAcquireReleaseInfoKHR {
-        Win32KeyedMutexAcquireReleaseInfoKHR {
-            s_type: StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             acquire_count: u32::default(),
             p_acquire_syncs: ::std::ptr::null(),
@@ -15602,10 +17378,13 @@ impl ::std::default::Default for Win32KeyedMutexAcquireReleaseInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for Win32KeyedMutexAcquireReleaseInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR;
+}
 impl Win32KeyedMutexAcquireReleaseInfoKHR {
     pub fn builder<'a>() -> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
         Win32KeyedMutexAcquireReleaseInfoKHRBuilder {
-            inner: Win32KeyedMutexAcquireReleaseInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15617,8 +17396,8 @@ pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
 }
 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
 unsafe impl ExtendsSubmitInfo for Win32KeyedMutexAcquireReleaseInfoKHR {}
-unsafe impl ExtendsSubmitInfo2KHR for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
-unsafe impl ExtendsSubmitInfo2KHR for Win32KeyedMutexAcquireReleaseInfoKHR {}
+unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'_> {}
+unsafe impl ExtendsSubmitInfo2 for Win32KeyedMutexAcquireReleaseInfoKHR {}
 impl<'a> ::std::ops::Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
     type Target = Win32KeyedMutexAcquireReleaseInfoKHR;
     fn deref(&self) -> &Self::Target {
@@ -15631,26 +17410,31 @@ impl<'a> ::std::ops::DerefMut for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a
     }
 }
 impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
+    #[inline]
     pub fn acquire_syncs(mut self, acquire_syncs: &'a [DeviceMemory]) -> Self {
         self.inner.acquire_count = acquire_syncs.len() as _;
         self.inner.p_acquire_syncs = acquire_syncs.as_ptr();
         self
     }
+    #[inline]
     pub fn acquire_keys(mut self, acquire_keys: &'a [u64]) -> Self {
         self.inner.acquire_count = acquire_keys.len() as _;
         self.inner.p_acquire_keys = acquire_keys.as_ptr();
         self
     }
+    #[inline]
     pub fn acquire_timeouts(mut self, acquire_timeouts: &'a [u32]) -> Self {
         self.inner.acquire_count = acquire_timeouts.len() as _;
         self.inner.p_acquire_timeouts = acquire_timeouts.as_ptr();
         self
     }
+    #[inline]
     pub fn release_syncs(mut self, release_syncs: &'a [DeviceMemory]) -> Self {
         self.inner.release_count = release_syncs.len() as _;
         self.inner.p_release_syncs = release_syncs.as_ptr();
         self
     }
+    #[inline]
     pub fn release_keys(mut self, release_keys: &'a [u64]) -> Self {
         self.inner.release_count = release_keys.len() as _;
         self.inner.p_release_keys = release_keys.as_ptr();
@@ -15664,26 +17448,31 @@ impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html>"]
 pub struct PhysicalDeviceExternalSemaphoreInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_type: ExternalSemaphoreHandleTypeFlags,
 }
 impl ::std::default::Default for PhysicalDeviceExternalSemaphoreInfo {
-    fn default() -> PhysicalDeviceExternalSemaphoreInfo {
-        PhysicalDeviceExternalSemaphoreInfo {
-            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceExternalSemaphoreInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
+}
 impl PhysicalDeviceExternalSemaphoreInfo {
     pub fn builder<'a>() -> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
         PhysicalDeviceExternalSemaphoreInfoBuilder {
-            inner: PhysicalDeviceExternalSemaphoreInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15706,6 +17495,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalSemaphoreInfoBuilder<'a>
     }
 }
 impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -15720,10 +17510,10 @@ impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -15735,8 +17525,9 @@ impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalSemaphoreProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalSemaphoreProperties.html>"]
 pub struct ExternalSemaphoreProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -15745,9 +17536,10 @@ pub struct ExternalSemaphoreProperties {
     pub external_semaphore_features: ExternalSemaphoreFeatureFlags,
 }
 impl ::std::default::Default for ExternalSemaphoreProperties {
-    fn default() -> ExternalSemaphoreProperties {
-        ExternalSemaphoreProperties {
-            s_type: StructureType::EXTERNAL_SEMAPHORE_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
             compatible_handle_types: ExternalSemaphoreHandleTypeFlags::default(),
@@ -15755,10 +17547,13 @@ impl ::std::default::Default for ExternalSemaphoreProperties {
         }
     }
 }
+unsafe impl TaggedStructure for ExternalSemaphoreProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_SEMAPHORE_PROPERTIES;
+}
 impl ExternalSemaphoreProperties {
     pub fn builder<'a>() -> ExternalSemaphorePropertiesBuilder<'a> {
         ExternalSemaphorePropertiesBuilder {
-            inner: ExternalSemaphoreProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15780,6 +17575,7 @@ impl<'a> ::std::ops::DerefMut for ExternalSemaphorePropertiesBuilder<'a> {
     }
 }
 impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
+    #[inline]
     pub fn export_from_imported_handle_types(
         mut self,
         export_from_imported_handle_types: ExternalSemaphoreHandleTypeFlags,
@@ -15787,6 +17583,7 @@ impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
         self
     }
+    #[inline]
     pub fn compatible_handle_types(
         mut self,
         compatible_handle_types: ExternalSemaphoreHandleTypeFlags,
@@ -15794,6 +17591,7 @@ impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
         self.inner.compatible_handle_types = compatible_handle_types;
         self
     }
+    #[inline]
     pub fn external_semaphore_features(
         mut self,
         external_semaphore_features: ExternalSemaphoreFeatureFlags,
@@ -15809,26 +17607,31 @@ impl<'a> ExternalSemaphorePropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportSemaphoreCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreCreateInfo.html>"]
 pub struct ExportSemaphoreCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_types: ExternalSemaphoreHandleTypeFlags,
 }
 impl ::std::default::Default for ExportSemaphoreCreateInfo {
-    fn default() -> ExportSemaphoreCreateInfo {
-        ExportSemaphoreCreateInfo {
-            s_type: StructureType::EXPORT_SEMAPHORE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_types: ExternalSemaphoreHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExportSemaphoreCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_SEMAPHORE_CREATE_INFO;
+}
 impl ExportSemaphoreCreateInfo {
     pub fn builder<'a>() -> ExportSemaphoreCreateInfoBuilder<'a> {
         ExportSemaphoreCreateInfoBuilder {
-            inner: ExportSemaphoreCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15852,6 +17655,7 @@ impl<'a> ::std::ops::DerefMut for ExportSemaphoreCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ExportSemaphoreCreateInfoBuilder<'a> {
+    #[inline]
     pub fn handle_types(mut self, handle_types: ExternalSemaphoreHandleTypeFlags) -> Self {
         self.inner.handle_types = handle_types;
         self
@@ -15864,8 +17668,9 @@ impl<'a> ExportSemaphoreCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportSemaphoreWin32HandleInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreWin32HandleInfoKHR.html>"]
 pub struct ImportSemaphoreWin32HandleInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -15876,9 +17681,10 @@ pub struct ImportSemaphoreWin32HandleInfoKHR {
     pub name: LPCWSTR,
 }
 impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR {
-    fn default() -> ImportSemaphoreWin32HandleInfoKHR {
-        ImportSemaphoreWin32HandleInfoKHR {
-            s_type: StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             semaphore: Semaphore::default(),
             flags: SemaphoreImportFlags::default(),
@@ -15888,10 +17694,13 @@ impl ::std::default::Default for ImportSemaphoreWin32HandleInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for ImportSemaphoreWin32HandleInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
+}
 impl ImportSemaphoreWin32HandleInfoKHR {
     pub fn builder<'a>() -> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
         ImportSemaphoreWin32HandleInfoKHRBuilder {
-            inner: ImportSemaphoreWin32HandleInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15913,22 +17722,27 @@ impl<'a> ::std::ops::DerefMut for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
+    #[inline]
     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
         self.inner.semaphore = semaphore;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn handle(mut self, handle: HANDLE) -> Self {
         self.inner.handle = handle;
         self
     }
+    #[inline]
     pub fn name(mut self, name: LPCWSTR) -> Self {
         self.inner.name = name;
         self
@@ -15941,8 +17755,9 @@ impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportSemaphoreWin32HandleInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportSemaphoreWin32HandleInfoKHR.html>"]
 pub struct ExportSemaphoreWin32HandleInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -15951,9 +17766,10 @@ pub struct ExportSemaphoreWin32HandleInfoKHR {
     pub name: LPCWSTR,
 }
 impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR {
-    fn default() -> ExportSemaphoreWin32HandleInfoKHR {
-        ExportSemaphoreWin32HandleInfoKHR {
-            s_type: StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_attributes: ::std::ptr::null(),
             dw_access: DWORD::default(),
@@ -15961,10 +17777,13 @@ impl ::std::default::Default for ExportSemaphoreWin32HandleInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for ExportSemaphoreWin32HandleInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
+}
 impl ExportSemaphoreWin32HandleInfoKHR {
     pub fn builder<'a>() -> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
         ExportSemaphoreWin32HandleInfoKHRBuilder {
-            inner: ExportSemaphoreWin32HandleInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -15988,14 +17807,17 @@ impl<'a> ::std::ops::DerefMut for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
+    #[inline]
     pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
         self.inner.p_attributes = attributes;
         self
     }
+    #[inline]
     pub fn dw_access(mut self, dw_access: DWORD) -> Self {
         self.inner.dw_access = dw_access;
         self
     }
+    #[inline]
     pub fn name(mut self, name: LPCWSTR) -> Self {
         self.inner.name = name;
         self
@@ -16008,8 +17830,9 @@ impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkD3D12FenceSubmitInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkD3D12FenceSubmitInfoKHR.html>"]
 pub struct D3D12FenceSubmitInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16019,9 +17842,10 @@ pub struct D3D12FenceSubmitInfoKHR {
     pub p_signal_semaphore_values: *const u64,
 }
 impl ::std::default::Default for D3D12FenceSubmitInfoKHR {
-    fn default() -> D3D12FenceSubmitInfoKHR {
-        D3D12FenceSubmitInfoKHR {
-            s_type: StructureType::D3D12_FENCE_SUBMIT_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             wait_semaphore_values_count: u32::default(),
             p_wait_semaphore_values: ::std::ptr::null(),
@@ -16030,10 +17854,13 @@ impl ::std::default::Default for D3D12FenceSubmitInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for D3D12FenceSubmitInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::D3D12_FENCE_SUBMIT_INFO_KHR;
+}
 impl D3D12FenceSubmitInfoKHR {
     pub fn builder<'a>() -> D3D12FenceSubmitInfoKHRBuilder<'a> {
         D3D12FenceSubmitInfoKHRBuilder {
-            inner: D3D12FenceSubmitInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16057,11 +17884,13 @@ impl<'a> ::std::ops::DerefMut for D3D12FenceSubmitInfoKHRBuilder<'a> {
     }
 }
 impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> {
+    #[inline]
     pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self {
         self.inner.wait_semaphore_values_count = wait_semaphore_values.len() as _;
         self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
         self
     }
+    #[inline]
     pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self {
         self.inner.signal_semaphore_values_count = signal_semaphore_values.len() as _;
         self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
@@ -16075,8 +17904,9 @@ impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreGetWin32HandleInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetWin32HandleInfoKHR.html>"]
 pub struct SemaphoreGetWin32HandleInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16084,19 +17914,23 @@ pub struct SemaphoreGetWin32HandleInfoKHR {
     pub handle_type: ExternalSemaphoreHandleTypeFlags,
 }
 impl ::std::default::Default for SemaphoreGetWin32HandleInfoKHR {
-    fn default() -> SemaphoreGetWin32HandleInfoKHR {
-        SemaphoreGetWin32HandleInfoKHR {
-            s_type: StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             semaphore: Semaphore::default(),
             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SemaphoreGetWin32HandleInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR;
+}
 impl SemaphoreGetWin32HandleInfoKHR {
     pub fn builder<'a>() -> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
         SemaphoreGetWin32HandleInfoKHRBuilder {
-            inner: SemaphoreGetWin32HandleInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16118,10 +17952,12 @@ impl<'a> ::std::ops::DerefMut for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
     }
 }
 impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
+    #[inline]
     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
         self.inner.semaphore = semaphore;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -16134,8 +17970,9 @@ impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportSemaphoreFdInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreFdInfoKHR.html>"]
 pub struct ImportSemaphoreFdInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16145,9 +17982,10 @@ pub struct ImportSemaphoreFdInfoKHR {
     pub fd: c_int,
 }
 impl ::std::default::Default for ImportSemaphoreFdInfoKHR {
-    fn default() -> ImportSemaphoreFdInfoKHR {
-        ImportSemaphoreFdInfoKHR {
-            s_type: StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             semaphore: Semaphore::default(),
             flags: SemaphoreImportFlags::default(),
@@ -16156,10 +17994,13 @@ impl ::std::default::Default for ImportSemaphoreFdInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for ImportSemaphoreFdInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_SEMAPHORE_FD_INFO_KHR;
+}
 impl ImportSemaphoreFdInfoKHR {
     pub fn builder<'a>() -> ImportSemaphoreFdInfoKHRBuilder<'a> {
         ImportSemaphoreFdInfoKHRBuilder {
-            inner: ImportSemaphoreFdInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16181,18 +18022,22 @@ impl<'a> ::std::ops::DerefMut for ImportSemaphoreFdInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> {
+    #[inline]
     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
         self.inner.semaphore = semaphore;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn fd(mut self, fd: c_int) -> Self {
         self.inner.fd = fd;
         self
@@ -16205,8 +18050,9 @@ impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreGetFdInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetFdInfoKHR.html>"]
 pub struct SemaphoreGetFdInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16214,19 +18060,23 @@ pub struct SemaphoreGetFdInfoKHR {
     pub handle_type: ExternalSemaphoreHandleTypeFlags,
 }
 impl ::std::default::Default for SemaphoreGetFdInfoKHR {
-    fn default() -> SemaphoreGetFdInfoKHR {
-        SemaphoreGetFdInfoKHR {
-            s_type: StructureType::SEMAPHORE_GET_FD_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             semaphore: Semaphore::default(),
             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SemaphoreGetFdInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_FD_INFO_KHR;
+}
 impl SemaphoreGetFdInfoKHR {
     pub fn builder<'a>() -> SemaphoreGetFdInfoKHRBuilder<'a> {
         SemaphoreGetFdInfoKHRBuilder {
-            inner: SemaphoreGetFdInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16248,10 +18098,12 @@ impl<'a> ::std::ops::DerefMut for SemaphoreGetFdInfoKHRBuilder<'a> {
     }
 }
 impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> {
+    #[inline]
     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
         self.inner.semaphore = semaphore;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -16264,8 +18116,9 @@ impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportSemaphoreZirconHandleInfoFUCHSIA.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportSemaphoreZirconHandleInfoFUCHSIA.html>"]
 pub struct ImportSemaphoreZirconHandleInfoFUCHSIA {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16275,9 +18128,10 @@ pub struct ImportSemaphoreZirconHandleInfoFUCHSIA {
     pub zircon_handle: zx_handle_t,
 }
 impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA {
-    fn default() -> ImportSemaphoreZirconHandleInfoFUCHSIA {
-        ImportSemaphoreZirconHandleInfoFUCHSIA {
-            s_type: StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             semaphore: Semaphore::default(),
             flags: SemaphoreImportFlags::default(),
@@ -16286,10 +18140,14 @@ impl ::std::default::Default for ImportSemaphoreZirconHandleInfoFUCHSIA {
         }
     }
 }
+unsafe impl TaggedStructure for ImportSemaphoreZirconHandleInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA;
+}
 impl ImportSemaphoreZirconHandleInfoFUCHSIA {
     pub fn builder<'a>() -> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
         ImportSemaphoreZirconHandleInfoFUCHSIABuilder {
-            inner: ImportSemaphoreZirconHandleInfoFUCHSIA::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16311,18 +18169,22 @@ impl<'a> ::std::ops::DerefMut for ImportSemaphoreZirconHandleInfoFUCHSIABuilder<
     }
 }
 impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
+    #[inline]
     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
         self.inner.semaphore = semaphore;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: SemaphoreImportFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn zircon_handle(mut self, zircon_handle: zx_handle_t) -> Self {
         self.inner.zircon_handle = zircon_handle;
         self
@@ -16335,8 +18197,9 @@ impl<'a> ImportSemaphoreZirconHandleInfoFUCHSIABuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreGetZirconHandleInfoFUCHSIA.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreGetZirconHandleInfoFUCHSIA.html>"]
 pub struct SemaphoreGetZirconHandleInfoFUCHSIA {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16344,19 +18207,23 @@ pub struct SemaphoreGetZirconHandleInfoFUCHSIA {
     pub handle_type: ExternalSemaphoreHandleTypeFlags,
 }
 impl ::std::default::Default for SemaphoreGetZirconHandleInfoFUCHSIA {
-    fn default() -> SemaphoreGetZirconHandleInfoFUCHSIA {
-        SemaphoreGetZirconHandleInfoFUCHSIA {
-            s_type: StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             semaphore: Semaphore::default(),
             handle_type: ExternalSemaphoreHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SemaphoreGetZirconHandleInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA;
+}
 impl SemaphoreGetZirconHandleInfoFUCHSIA {
     pub fn builder<'a>() -> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
         SemaphoreGetZirconHandleInfoFUCHSIABuilder {
-            inner: SemaphoreGetZirconHandleInfoFUCHSIA::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16378,10 +18245,12 @@ impl<'a> ::std::ops::DerefMut for SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a>
     }
 }
 impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
+    #[inline]
     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
         self.inner.semaphore = semaphore;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalSemaphoreHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -16394,26 +18263,31 @@ impl<'a> SemaphoreGetZirconHandleInfoFUCHSIABuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalFenceInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalFenceInfo.html>"]
 pub struct PhysicalDeviceExternalFenceInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_type: ExternalFenceHandleTypeFlags,
 }
 impl ::std::default::Default for PhysicalDeviceExternalFenceInfo {
-    fn default() -> PhysicalDeviceExternalFenceInfo {
-        PhysicalDeviceExternalFenceInfo {
-            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_type: ExternalFenceHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceExternalFenceInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
+}
 impl PhysicalDeviceExternalFenceInfo {
     pub fn builder<'a>() -> PhysicalDeviceExternalFenceInfoBuilder<'a> {
         PhysicalDeviceExternalFenceInfoBuilder {
-            inner: PhysicalDeviceExternalFenceInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16435,6 +18309,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalFenceInfoBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> {
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -16447,8 +18322,9 @@ impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFenceProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFenceProperties.html>"]
 pub struct ExternalFenceProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -16457,9 +18333,10 @@ pub struct ExternalFenceProperties {
     pub external_fence_features: ExternalFenceFeatureFlags,
 }
 impl ::std::default::Default for ExternalFenceProperties {
-    fn default() -> ExternalFenceProperties {
-        ExternalFenceProperties {
-            s_type: StructureType::EXTERNAL_FENCE_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             export_from_imported_handle_types: ExternalFenceHandleTypeFlags::default(),
             compatible_handle_types: ExternalFenceHandleTypeFlags::default(),
@@ -16467,10 +18344,13 @@ impl ::std::default::Default for ExternalFenceProperties {
         }
     }
 }
+unsafe impl TaggedStructure for ExternalFenceProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_FENCE_PROPERTIES;
+}
 impl ExternalFenceProperties {
     pub fn builder<'a>() -> ExternalFencePropertiesBuilder<'a> {
         ExternalFencePropertiesBuilder {
-            inner: ExternalFenceProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16492,6 +18372,7 @@ impl<'a> ::std::ops::DerefMut for ExternalFencePropertiesBuilder<'a> {
     }
 }
 impl<'a> ExternalFencePropertiesBuilder<'a> {
+    #[inline]
     pub fn export_from_imported_handle_types(
         mut self,
         export_from_imported_handle_types: ExternalFenceHandleTypeFlags,
@@ -16499,6 +18380,7 @@ impl<'a> ExternalFencePropertiesBuilder<'a> {
         self.inner.export_from_imported_handle_types = export_from_imported_handle_types;
         self
     }
+    #[inline]
     pub fn compatible_handle_types(
         mut self,
         compatible_handle_types: ExternalFenceHandleTypeFlags,
@@ -16506,6 +18388,7 @@ impl<'a> ExternalFencePropertiesBuilder<'a> {
         self.inner.compatible_handle_types = compatible_handle_types;
         self
     }
+    #[inline]
     pub fn external_fence_features(
         mut self,
         external_fence_features: ExternalFenceFeatureFlags,
@@ -16521,26 +18404,31 @@ impl<'a> ExternalFencePropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportFenceCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceCreateInfo.html>"]
 pub struct ExportFenceCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub handle_types: ExternalFenceHandleTypeFlags,
 }
 impl ::std::default::Default for ExportFenceCreateInfo {
-    fn default() -> ExportFenceCreateInfo {
-        ExportFenceCreateInfo {
-            s_type: StructureType::EXPORT_FENCE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_types: ExternalFenceHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExportFenceCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_FENCE_CREATE_INFO;
+}
 impl ExportFenceCreateInfo {
     pub fn builder<'a>() -> ExportFenceCreateInfoBuilder<'a> {
         ExportFenceCreateInfoBuilder {
-            inner: ExportFenceCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16564,6 +18452,7 @@ impl<'a> ::std::ops::DerefMut for ExportFenceCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ExportFenceCreateInfoBuilder<'a> {
+    #[inline]
     pub fn handle_types(mut self, handle_types: ExternalFenceHandleTypeFlags) -> Self {
         self.inner.handle_types = handle_types;
         self
@@ -16576,8 +18465,9 @@ impl<'a> ExportFenceCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportFenceWin32HandleInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportFenceWin32HandleInfoKHR.html>"]
 pub struct ImportFenceWin32HandleInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16588,9 +18478,10 @@ pub struct ImportFenceWin32HandleInfoKHR {
     pub name: LPCWSTR,
 }
 impl ::std::default::Default for ImportFenceWin32HandleInfoKHR {
-    fn default() -> ImportFenceWin32HandleInfoKHR {
-        ImportFenceWin32HandleInfoKHR {
-            s_type: StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             fence: Fence::default(),
             flags: FenceImportFlags::default(),
@@ -16600,10 +18491,13 @@ impl ::std::default::Default for ImportFenceWin32HandleInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for ImportFenceWin32HandleInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_FENCE_WIN32_HANDLE_INFO_KHR;
+}
 impl ImportFenceWin32HandleInfoKHR {
     pub fn builder<'a>() -> ImportFenceWin32HandleInfoKHRBuilder<'a> {
         ImportFenceWin32HandleInfoKHRBuilder {
-            inner: ImportFenceWin32HandleInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16625,22 +18519,27 @@ impl<'a> ::std::ops::DerefMut for ImportFenceWin32HandleInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> {
+    #[inline]
     pub fn fence(mut self, fence: Fence) -> Self {
         self.inner.fence = fence;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: FenceImportFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn handle(mut self, handle: HANDLE) -> Self {
         self.inner.handle = handle;
         self
     }
+    #[inline]
     pub fn name(mut self, name: LPCWSTR) -> Self {
         self.inner.name = name;
         self
@@ -16653,8 +18552,9 @@ impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExportFenceWin32HandleInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportFenceWin32HandleInfoKHR.html>"]
 pub struct ExportFenceWin32HandleInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16663,9 +18563,10 @@ pub struct ExportFenceWin32HandleInfoKHR {
     pub name: LPCWSTR,
 }
 impl ::std::default::Default for ExportFenceWin32HandleInfoKHR {
-    fn default() -> ExportFenceWin32HandleInfoKHR {
-        ExportFenceWin32HandleInfoKHR {
-            s_type: StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_attributes: ::std::ptr::null(),
             dw_access: DWORD::default(),
@@ -16673,10 +18574,13 @@ impl ::std::default::Default for ExportFenceWin32HandleInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for ExportFenceWin32HandleInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_FENCE_WIN32_HANDLE_INFO_KHR;
+}
 impl ExportFenceWin32HandleInfoKHR {
     pub fn builder<'a>() -> ExportFenceWin32HandleInfoKHRBuilder<'a> {
         ExportFenceWin32HandleInfoKHRBuilder {
-            inner: ExportFenceWin32HandleInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16700,14 +18604,17 @@ impl<'a> ::std::ops::DerefMut for ExportFenceWin32HandleInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> {
+    #[inline]
     pub fn attributes(mut self, attributes: &'a SECURITY_ATTRIBUTES) -> Self {
         self.inner.p_attributes = attributes;
         self
     }
+    #[inline]
     pub fn dw_access(mut self, dw_access: DWORD) -> Self {
         self.inner.dw_access = dw_access;
         self
     }
+    #[inline]
     pub fn name(mut self, name: LPCWSTR) -> Self {
         self.inner.name = name;
         self
@@ -16720,8 +18627,9 @@ impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceGetWin32HandleInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetWin32HandleInfoKHR.html>"]
 pub struct FenceGetWin32HandleInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16729,19 +18637,23 @@ pub struct FenceGetWin32HandleInfoKHR {
     pub handle_type: ExternalFenceHandleTypeFlags,
 }
 impl ::std::default::Default for FenceGetWin32HandleInfoKHR {
-    fn default() -> FenceGetWin32HandleInfoKHR {
-        FenceGetWin32HandleInfoKHR {
-            s_type: StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             fence: Fence::default(),
             handle_type: ExternalFenceHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for FenceGetWin32HandleInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::FENCE_GET_WIN32_HANDLE_INFO_KHR;
+}
 impl FenceGetWin32HandleInfoKHR {
     pub fn builder<'a>() -> FenceGetWin32HandleInfoKHRBuilder<'a> {
         FenceGetWin32HandleInfoKHRBuilder {
-            inner: FenceGetWin32HandleInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16763,10 +18675,12 @@ impl<'a> ::std::ops::DerefMut for FenceGetWin32HandleInfoKHRBuilder<'a> {
     }
 }
 impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> {
+    #[inline]
     pub fn fence(mut self, fence: Fence) -> Self {
         self.inner.fence = fence;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -16779,8 +18693,9 @@ impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportFenceFdInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportFenceFdInfoKHR.html>"]
 pub struct ImportFenceFdInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16790,9 +18705,10 @@ pub struct ImportFenceFdInfoKHR {
     pub fd: c_int,
 }
 impl ::std::default::Default for ImportFenceFdInfoKHR {
-    fn default() -> ImportFenceFdInfoKHR {
-        ImportFenceFdInfoKHR {
-            s_type: StructureType::IMPORT_FENCE_FD_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             fence: Fence::default(),
             flags: FenceImportFlags::default(),
@@ -16801,10 +18717,13 @@ impl ::std::default::Default for ImportFenceFdInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for ImportFenceFdInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_FENCE_FD_INFO_KHR;
+}
 impl ImportFenceFdInfoKHR {
     pub fn builder<'a>() -> ImportFenceFdInfoKHRBuilder<'a> {
         ImportFenceFdInfoKHRBuilder {
-            inner: ImportFenceFdInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16826,18 +18745,22 @@ impl<'a> ::std::ops::DerefMut for ImportFenceFdInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ImportFenceFdInfoKHRBuilder<'a> {
+    #[inline]
     pub fn fence(mut self, fence: Fence) -> Self {
         self.inner.fence = fence;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: FenceImportFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn fd(mut self, fd: c_int) -> Self {
         self.inner.fd = fd;
         self
@@ -16850,8 +18773,9 @@ impl<'a> ImportFenceFdInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFenceGetFdInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFenceGetFdInfoKHR.html>"]
 pub struct FenceGetFdInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -16859,19 +18783,23 @@ pub struct FenceGetFdInfoKHR {
     pub handle_type: ExternalFenceHandleTypeFlags,
 }
 impl ::std::default::Default for FenceGetFdInfoKHR {
-    fn default() -> FenceGetFdInfoKHR {
-        FenceGetFdInfoKHR {
-            s_type: StructureType::FENCE_GET_FD_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             fence: Fence::default(),
             handle_type: ExternalFenceHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for FenceGetFdInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::FENCE_GET_FD_INFO_KHR;
+}
 impl FenceGetFdInfoKHR {
     pub fn builder<'a>() -> FenceGetFdInfoKHRBuilder<'a> {
         FenceGetFdInfoKHRBuilder {
-            inner: FenceGetFdInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16893,10 +18821,12 @@ impl<'a> ::std::ops::DerefMut for FenceGetFdInfoKHRBuilder<'a> {
     }
 }
 impl<'a> FenceGetFdInfoKHRBuilder<'a> {
+    #[inline]
     pub fn fence(mut self, fence: Fence) -> Self {
         self.inner.fence = fence;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalFenceHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -16909,8 +18839,9 @@ impl<'a> FenceGetFdInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewFeatures.html>"]
 pub struct PhysicalDeviceMultiviewFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -16919,9 +18850,10 @@ pub struct PhysicalDeviceMultiviewFeatures {
     pub multiview_tessellation_shader: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceMultiviewFeatures {
-    fn default() -> PhysicalDeviceMultiviewFeatures {
-        PhysicalDeviceMultiviewFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             multiview: Bool32::default(),
             multiview_geometry_shader: Bool32::default(),
@@ -16929,10 +18861,13 @@ impl ::std::default::Default for PhysicalDeviceMultiviewFeatures {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMultiviewFeatures {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
+}
 impl PhysicalDeviceMultiviewFeatures {
     pub fn builder<'a>() -> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
         PhysicalDeviceMultiviewFeaturesBuilder {
-            inner: PhysicalDeviceMultiviewFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -16958,14 +18893,17 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
+    #[inline]
     pub fn multiview(mut self, multiview: bool) -> Self {
         self.inner.multiview = multiview.into();
         self
     }
+    #[inline]
     pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
         self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
         self
     }
+    #[inline]
     pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
         self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
         self
@@ -16978,8 +18916,9 @@ impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewProperties.html>"]
 pub struct PhysicalDeviceMultiviewProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -16987,19 +18926,23 @@ pub struct PhysicalDeviceMultiviewProperties {
     pub max_multiview_instance_index: u32,
 }
 impl ::std::default::Default for PhysicalDeviceMultiviewProperties {
-    fn default() -> PhysicalDeviceMultiviewProperties {
-        PhysicalDeviceMultiviewProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_multiview_view_count: u32::default(),
             max_multiview_instance_index: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMultiviewProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
+}
 impl PhysicalDeviceMultiviewProperties {
     pub fn builder<'a>() -> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
         PhysicalDeviceMultiviewPropertiesBuilder {
-            inner: PhysicalDeviceMultiviewProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17023,10 +18966,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
+    #[inline]
     pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
         self.inner.max_multiview_view_count = max_multiview_view_count;
         self
     }
+    #[inline]
     pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
         self.inner.max_multiview_instance_index = max_multiview_instance_index;
         self
@@ -17039,8 +18984,9 @@ impl<'a> PhysicalDeviceMultiviewPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassMultiviewCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassMultiviewCreateInfo.html>"]
 pub struct RenderPassMultiviewCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -17052,9 +18998,10 @@ pub struct RenderPassMultiviewCreateInfo {
     pub p_correlation_masks: *const u32,
 }
 impl ::std::default::Default for RenderPassMultiviewCreateInfo {
-    fn default() -> RenderPassMultiviewCreateInfo {
-        RenderPassMultiviewCreateInfo {
-            s_type: StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             subpass_count: u32::default(),
             p_view_masks: ::std::ptr::null(),
@@ -17065,10 +19012,13 @@ impl ::std::default::Default for RenderPassMultiviewCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for RenderPassMultiviewCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_MULTIVIEW_CREATE_INFO;
+}
 impl RenderPassMultiviewCreateInfo {
     pub fn builder<'a>() -> RenderPassMultiviewCreateInfoBuilder<'a> {
         RenderPassMultiviewCreateInfoBuilder {
-            inner: RenderPassMultiviewCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17092,16 +19042,19 @@ impl<'a> ::std::ops::DerefMut for RenderPassMultiviewCreateInfoBuilder<'a> {
     }
 }
 impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> {
+    #[inline]
     pub fn view_masks(mut self, view_masks: &'a [u32]) -> Self {
         self.inner.subpass_count = view_masks.len() as _;
         self.inner.p_view_masks = view_masks.as_ptr();
         self
     }
+    #[inline]
     pub fn view_offsets(mut self, view_offsets: &'a [i32]) -> Self {
         self.inner.dependency_count = view_offsets.len() as _;
         self.inner.p_view_offsets = view_offsets.as_ptr();
         self
     }
+    #[inline]
     pub fn correlation_masks(mut self, correlation_masks: &'a [u32]) -> Self {
         self.inner.correlation_mask_count = correlation_masks.len() as _;
         self.inner.p_correlation_masks = correlation_masks.as_ptr();
@@ -17115,8 +19068,9 @@ impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilities2EXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilities2EXT.html>"]
 pub struct SurfaceCapabilities2EXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -17133,9 +19087,10 @@ pub struct SurfaceCapabilities2EXT {
     pub supported_surface_counters: SurfaceCounterFlagsEXT,
 }
 impl ::std::default::Default for SurfaceCapabilities2EXT {
-    fn default() -> SurfaceCapabilities2EXT {
-        SurfaceCapabilities2EXT {
-            s_type: StructureType::SURFACE_CAPABILITIES_2_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             min_image_count: u32::default(),
             max_image_count: u32::default(),
@@ -17151,10 +19106,13 @@ impl ::std::default::Default for SurfaceCapabilities2EXT {
         }
     }
 }
+unsafe impl TaggedStructure for SurfaceCapabilities2EXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_2_EXT;
+}
 impl SurfaceCapabilities2EXT {
     pub fn builder<'a>() -> SurfaceCapabilities2EXTBuilder<'a> {
         SurfaceCapabilities2EXTBuilder {
-            inner: SurfaceCapabilities2EXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17176,38 +19134,47 @@ impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2EXTBuilder<'a> {
     }
 }
 impl<'a> SurfaceCapabilities2EXTBuilder<'a> {
+    #[inline]
     pub fn min_image_count(mut self, min_image_count: u32) -> Self {
         self.inner.min_image_count = min_image_count;
         self
     }
+    #[inline]
     pub fn max_image_count(mut self, max_image_count: u32) -> Self {
         self.inner.max_image_count = max_image_count;
         self
     }
+    #[inline]
     pub fn current_extent(mut self, current_extent: Extent2D) -> Self {
         self.inner.current_extent = current_extent;
         self
     }
+    #[inline]
     pub fn min_image_extent(mut self, min_image_extent: Extent2D) -> Self {
         self.inner.min_image_extent = min_image_extent;
         self
     }
+    #[inline]
     pub fn max_image_extent(mut self, max_image_extent: Extent2D) -> Self {
         self.inner.max_image_extent = max_image_extent;
         self
     }
+    #[inline]
     pub fn max_image_array_layers(mut self, max_image_array_layers: u32) -> Self {
         self.inner.max_image_array_layers = max_image_array_layers;
         self
     }
+    #[inline]
     pub fn supported_transforms(mut self, supported_transforms: SurfaceTransformFlagsKHR) -> Self {
         self.inner.supported_transforms = supported_transforms;
         self
     }
+    #[inline]
     pub fn current_transform(mut self, current_transform: SurfaceTransformFlagsKHR) -> Self {
         self.inner.current_transform = current_transform;
         self
     }
+    #[inline]
     pub fn supported_composite_alpha(
         mut self,
         supported_composite_alpha: CompositeAlphaFlagsKHR,
@@ -17215,10 +19182,12 @@ impl<'a> SurfaceCapabilities2EXTBuilder<'a> {
         self.inner.supported_composite_alpha = supported_composite_alpha;
         self
     }
+    #[inline]
     pub fn supported_usage_flags(mut self, supported_usage_flags: ImageUsageFlags) -> Self {
         self.inner.supported_usage_flags = supported_usage_flags;
         self
     }
+    #[inline]
     pub fn supported_surface_counters(
         mut self,
         supported_surface_counters: SurfaceCounterFlagsEXT,
@@ -17234,26 +19203,31 @@ impl<'a> SurfaceCapabilities2EXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPowerInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPowerInfoEXT.html>"]
 pub struct DisplayPowerInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub power_state: DisplayPowerStateEXT,
 }
 impl ::std::default::Default for DisplayPowerInfoEXT {
-    fn default() -> DisplayPowerInfoEXT {
-        DisplayPowerInfoEXT {
-            s_type: StructureType::DISPLAY_POWER_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             power_state: DisplayPowerStateEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DisplayPowerInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_POWER_INFO_EXT;
+}
 impl DisplayPowerInfoEXT {
     pub fn builder<'a>() -> DisplayPowerInfoEXTBuilder<'a> {
         DisplayPowerInfoEXTBuilder {
-            inner: DisplayPowerInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17275,6 +19249,7 @@ impl<'a> ::std::ops::DerefMut for DisplayPowerInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DisplayPowerInfoEXTBuilder<'a> {
+    #[inline]
     pub fn power_state(mut self, power_state: DisplayPowerStateEXT) -> Self {
         self.inner.power_state = power_state;
         self
@@ -17287,26 +19262,31 @@ impl<'a> DisplayPowerInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceEventInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceEventInfoEXT.html>"]
 pub struct DeviceEventInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub device_event: DeviceEventTypeEXT,
 }
 impl ::std::default::Default for DeviceEventInfoEXT {
-    fn default() -> DeviceEventInfoEXT {
-        DeviceEventInfoEXT {
-            s_type: StructureType::DEVICE_EVENT_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             device_event: DeviceEventTypeEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DeviceEventInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_EVENT_INFO_EXT;
+}
 impl DeviceEventInfoEXT {
     pub fn builder<'a>() -> DeviceEventInfoEXTBuilder<'a> {
         DeviceEventInfoEXTBuilder {
-            inner: DeviceEventInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17328,6 +19308,7 @@ impl<'a> ::std::ops::DerefMut for DeviceEventInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DeviceEventInfoEXTBuilder<'a> {
+    #[inline]
     pub fn device_event(mut self, device_event: DeviceEventTypeEXT) -> Self {
         self.inner.device_event = device_event;
         self
@@ -17340,26 +19321,31 @@ impl<'a> DeviceEventInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayEventInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayEventInfoEXT.html>"]
 pub struct DisplayEventInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub display_event: DisplayEventTypeEXT,
 }
 impl ::std::default::Default for DisplayEventInfoEXT {
-    fn default() -> DisplayEventInfoEXT {
-        DisplayEventInfoEXT {
-            s_type: StructureType::DISPLAY_EVENT_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             display_event: DisplayEventTypeEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DisplayEventInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_EVENT_INFO_EXT;
+}
 impl DisplayEventInfoEXT {
     pub fn builder<'a>() -> DisplayEventInfoEXTBuilder<'a> {
         DisplayEventInfoEXTBuilder {
-            inner: DisplayEventInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17381,6 +19367,7 @@ impl<'a> ::std::ops::DerefMut for DisplayEventInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DisplayEventInfoEXTBuilder<'a> {
+    #[inline]
     pub fn display_event(mut self, display_event: DisplayEventTypeEXT) -> Self {
         self.inner.display_event = display_event;
         self
@@ -17393,26 +19380,31 @@ impl<'a> DisplayEventInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainCounterCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainCounterCreateInfoEXT.html>"]
 pub struct SwapchainCounterCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub surface_counters: SurfaceCounterFlagsEXT,
 }
 impl ::std::default::Default for SwapchainCounterCreateInfoEXT {
-    fn default() -> SwapchainCounterCreateInfoEXT {
-        SwapchainCounterCreateInfoEXT {
-            s_type: StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             surface_counters: SurfaceCounterFlagsEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SwapchainCounterCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_COUNTER_CREATE_INFO_EXT;
+}
 impl SwapchainCounterCreateInfoEXT {
     pub fn builder<'a>() -> SwapchainCounterCreateInfoEXTBuilder<'a> {
         SwapchainCounterCreateInfoEXTBuilder {
-            inner: SwapchainCounterCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17436,6 +19428,7 @@ impl<'a> ::std::ops::DerefMut for SwapchainCounterCreateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn surface_counters(mut self, surface_counters: SurfaceCounterFlagsEXT) -> Self {
         self.inner.surface_counters = surface_counters;
         self
@@ -17448,8 +19441,9 @@ impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceGroupProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGroupProperties.html>"]
 pub struct PhysicalDeviceGroupProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -17458,9 +19452,10 @@ pub struct PhysicalDeviceGroupProperties {
     pub subset_allocation: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceGroupProperties {
-    fn default() -> PhysicalDeviceGroupProperties {
-        PhysicalDeviceGroupProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             physical_device_count: u32::default(),
             physical_devices: unsafe { ::std::mem::zeroed() },
@@ -17468,10 +19463,13 @@ impl ::std::default::Default for PhysicalDeviceGroupProperties {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceGroupProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_GROUP_PROPERTIES;
+}
 impl PhysicalDeviceGroupProperties {
     pub fn builder<'a>() -> PhysicalDeviceGroupPropertiesBuilder<'a> {
         PhysicalDeviceGroupPropertiesBuilder {
-            inner: PhysicalDeviceGroupProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17493,10 +19491,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceGroupPropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> {
+    #[inline]
     pub fn physical_device_count(mut self, physical_device_count: u32) -> Self {
         self.inner.physical_device_count = physical_device_count;
         self
     }
+    #[inline]
     pub fn physical_devices(
         mut self,
         physical_devices: [PhysicalDevice; MAX_DEVICE_GROUP_SIZE],
@@ -17504,6 +19504,7 @@ impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> {
         self.inner.physical_devices = physical_devices;
         self
     }
+    #[inline]
     pub fn subset_allocation(mut self, subset_allocation: bool) -> Self {
         self.inner.subset_allocation = subset_allocation.into();
         self
@@ -17516,8 +19517,9 @@ impl<'a> PhysicalDeviceGroupPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryAllocateFlagsInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryAllocateFlagsInfo.html>"]
 pub struct MemoryAllocateFlagsInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -17525,19 +19527,23 @@ pub struct MemoryAllocateFlagsInfo {
     pub device_mask: u32,
 }
 impl ::std::default::Default for MemoryAllocateFlagsInfo {
-    fn default() -> MemoryAllocateFlagsInfo {
-        MemoryAllocateFlagsInfo {
-            s_type: StructureType::MEMORY_ALLOCATE_FLAGS_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: MemoryAllocateFlags::default(),
             device_mask: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryAllocateFlagsInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_ALLOCATE_FLAGS_INFO;
+}
 impl MemoryAllocateFlagsInfo {
     pub fn builder<'a>() -> MemoryAllocateFlagsInfoBuilder<'a> {
         MemoryAllocateFlagsInfoBuilder {
-            inner: MemoryAllocateFlagsInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17561,10 +19567,12 @@ impl<'a> ::std::ops::DerefMut for MemoryAllocateFlagsInfoBuilder<'a> {
     }
 }
 impl<'a> MemoryAllocateFlagsInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: MemoryAllocateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn device_mask(mut self, device_mask: u32) -> Self {
         self.inner.device_mask = device_mask;
         self
@@ -17577,8 +19585,9 @@ impl<'a> MemoryAllocateFlagsInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindBufferMemoryInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryInfo.html>"]
 pub struct BindBufferMemoryInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -17587,9 +19596,10 @@ pub struct BindBufferMemoryInfo {
     pub memory_offset: DeviceSize,
 }
 impl ::std::default::Default for BindBufferMemoryInfo {
-    fn default() -> BindBufferMemoryInfo {
-        BindBufferMemoryInfo {
-            s_type: StructureType::BIND_BUFFER_MEMORY_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             buffer: Buffer::default(),
             memory: DeviceMemory::default(),
@@ -17597,10 +19607,13 @@ impl ::std::default::Default for BindBufferMemoryInfo {
         }
     }
 }
+unsafe impl TaggedStructure for BindBufferMemoryInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BIND_BUFFER_MEMORY_INFO;
+}
 impl BindBufferMemoryInfo {
     pub fn builder<'a>() -> BindBufferMemoryInfoBuilder<'a> {
         BindBufferMemoryInfoBuilder {
-            inner: BindBufferMemoryInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17623,14 +19636,17 @@ impl<'a> ::std::ops::DerefMut for BindBufferMemoryInfoBuilder<'a> {
     }
 }
 impl<'a> BindBufferMemoryInfoBuilder<'a> {
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
     }
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
         self.inner.memory_offset = memory_offset;
         self
@@ -17642,10 +19658,10 @@ impl<'a> BindBufferMemoryInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsBindBufferMemoryInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -17657,8 +19673,9 @@ impl<'a> BindBufferMemoryInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindBufferMemoryDeviceGroupInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindBufferMemoryDeviceGroupInfo.html>"]
 pub struct BindBufferMemoryDeviceGroupInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -17666,19 +19683,23 @@ pub struct BindBufferMemoryDeviceGroupInfo {
     pub p_device_indices: *const u32,
 }
 impl ::std::default::Default for BindBufferMemoryDeviceGroupInfo {
-    fn default() -> BindBufferMemoryDeviceGroupInfo {
-        BindBufferMemoryDeviceGroupInfo {
-            s_type: StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             device_index_count: u32::default(),
             p_device_indices: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for BindBufferMemoryDeviceGroupInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
+}
 impl BindBufferMemoryDeviceGroupInfo {
     pub fn builder<'a>() -> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
         BindBufferMemoryDeviceGroupInfoBuilder {
-            inner: BindBufferMemoryDeviceGroupInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17702,6 +19723,7 @@ impl<'a> ::std::ops::DerefMut for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
     }
 }
 impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
+    #[inline]
     pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
         self.inner.device_index_count = device_indices.len() as _;
         self.inner.p_device_indices = device_indices.as_ptr();
@@ -17715,8 +19737,9 @@ impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImageMemoryInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryInfo.html>"]
 pub struct BindImageMemoryInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -17725,9 +19748,10 @@ pub struct BindImageMemoryInfo {
     pub memory_offset: DeviceSize,
 }
 impl ::std::default::Default for BindImageMemoryInfo {
-    fn default() -> BindImageMemoryInfo {
-        BindImageMemoryInfo {
-            s_type: StructureType::BIND_IMAGE_MEMORY_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             image: Image::default(),
             memory: DeviceMemory::default(),
@@ -17735,10 +19759,13 @@ impl ::std::default::Default for BindImageMemoryInfo {
         }
     }
 }
+unsafe impl TaggedStructure for BindImageMemoryInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_INFO;
+}
 impl BindImageMemoryInfo {
     pub fn builder<'a>() -> BindImageMemoryInfoBuilder<'a> {
         BindImageMemoryInfoBuilder {
-            inner: BindImageMemoryInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17761,14 +19788,17 @@ impl<'a> ::std::ops::DerefMut for BindImageMemoryInfoBuilder<'a> {
     }
 }
 impl<'a> BindImageMemoryInfoBuilder<'a> {
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
     }
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
         self.inner.memory_offset = memory_offset;
         self
@@ -17780,10 +19810,10 @@ impl<'a> BindImageMemoryInfoBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsBindImageMemoryInfo>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -17795,8 +19825,9 @@ impl<'a> BindImageMemoryInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImageMemoryDeviceGroupInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemoryDeviceGroupInfo.html>"]
 pub struct BindImageMemoryDeviceGroupInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -17806,9 +19837,10 @@ pub struct BindImageMemoryDeviceGroupInfo {
     pub p_split_instance_bind_regions: *const Rect2D,
 }
 impl ::std::default::Default for BindImageMemoryDeviceGroupInfo {
-    fn default() -> BindImageMemoryDeviceGroupInfo {
-        BindImageMemoryDeviceGroupInfo {
-            s_type: StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             device_index_count: u32::default(),
             p_device_indices: ::std::ptr::null(),
@@ -17817,10 +19849,13 @@ impl ::std::default::Default for BindImageMemoryDeviceGroupInfo {
         }
     }
 }
+unsafe impl TaggedStructure for BindImageMemoryDeviceGroupInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
+}
 impl BindImageMemoryDeviceGroupInfo {
     pub fn builder<'a>() -> BindImageMemoryDeviceGroupInfoBuilder<'a> {
         BindImageMemoryDeviceGroupInfoBuilder {
-            inner: BindImageMemoryDeviceGroupInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17844,11 +19879,13 @@ impl<'a> ::std::ops::DerefMut for BindImageMemoryDeviceGroupInfoBuilder<'a> {
     }
 }
 impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> {
+    #[inline]
     pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
         self.inner.device_index_count = device_indices.len() as _;
         self.inner.p_device_indices = device_indices.as_ptr();
         self
     }
+    #[inline]
     pub fn split_instance_bind_regions(
         mut self,
         split_instance_bind_regions: &'a [Rect2D],
@@ -17865,8 +19902,9 @@ impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupRenderPassBeginInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupRenderPassBeginInfo.html>"]
 pub struct DeviceGroupRenderPassBeginInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -17875,9 +19913,10 @@ pub struct DeviceGroupRenderPassBeginInfo {
     pub p_device_render_areas: *const Rect2D,
 }
 impl ::std::default::Default for DeviceGroupRenderPassBeginInfo {
-    fn default() -> DeviceGroupRenderPassBeginInfo {
-        DeviceGroupRenderPassBeginInfo {
-            s_type: StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             device_mask: u32::default(),
             device_render_area_count: u32::default(),
@@ -17885,10 +19924,13 @@ impl ::std::default::Default for DeviceGroupRenderPassBeginInfo {
         }
     }
 }
+unsafe impl TaggedStructure for DeviceGroupRenderPassBeginInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
+}
 impl DeviceGroupRenderPassBeginInfo {
     pub fn builder<'a>() -> DeviceGroupRenderPassBeginInfoBuilder<'a> {
         DeviceGroupRenderPassBeginInfoBuilder {
-            inner: DeviceGroupRenderPassBeginInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17900,6 +19942,8 @@ pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> {
 }
 unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
 unsafe impl ExtendsRenderPassBeginInfo for DeviceGroupRenderPassBeginInfo {}
+unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfoBuilder<'_> {}
+unsafe impl ExtendsRenderingInfo for DeviceGroupRenderPassBeginInfo {}
 impl<'a> ::std::ops::Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> {
     type Target = DeviceGroupRenderPassBeginInfo;
     fn deref(&self) -> &Self::Target {
@@ -17912,10 +19956,12 @@ impl<'a> ::std::ops::DerefMut for DeviceGroupRenderPassBeginInfoBuilder<'a> {
     }
 }
 impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> {
+    #[inline]
     pub fn device_mask(mut self, device_mask: u32) -> Self {
         self.inner.device_mask = device_mask;
         self
     }
+    #[inline]
     pub fn device_render_areas(mut self, device_render_areas: &'a [Rect2D]) -> Self {
         self.inner.device_render_area_count = device_render_areas.len() as _;
         self.inner.p_device_render_areas = device_render_areas.as_ptr();
@@ -17929,26 +19975,31 @@ impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupCommandBufferBeginInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupCommandBufferBeginInfo.html>"]
 pub struct DeviceGroupCommandBufferBeginInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub device_mask: u32,
 }
 impl ::std::default::Default for DeviceGroupCommandBufferBeginInfo {
-    fn default() -> DeviceGroupCommandBufferBeginInfo {
-        DeviceGroupCommandBufferBeginInfo {
-            s_type: StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             device_mask: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DeviceGroupCommandBufferBeginInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
+}
 impl DeviceGroupCommandBufferBeginInfo {
     pub fn builder<'a>() -> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
         DeviceGroupCommandBufferBeginInfoBuilder {
-            inner: DeviceGroupCommandBufferBeginInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -17972,6 +20023,7 @@ impl<'a> ::std::ops::DerefMut for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
     }
 }
 impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
+    #[inline]
     pub fn device_mask(mut self, device_mask: u32) -> Self {
         self.inner.device_mask = device_mask;
         self
@@ -17984,8 +20036,9 @@ impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupSubmitInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSubmitInfo.html>"]
 pub struct DeviceGroupSubmitInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -17997,9 +20050,10 @@ pub struct DeviceGroupSubmitInfo {
     pub p_signal_semaphore_device_indices: *const u32,
 }
 impl ::std::default::Default for DeviceGroupSubmitInfo {
-    fn default() -> DeviceGroupSubmitInfo {
-        DeviceGroupSubmitInfo {
-            s_type: StructureType::DEVICE_GROUP_SUBMIT_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             wait_semaphore_count: u32::default(),
             p_wait_semaphore_device_indices: ::std::ptr::null(),
@@ -18010,10 +20064,13 @@ impl ::std::default::Default for DeviceGroupSubmitInfo {
         }
     }
 }
+unsafe impl TaggedStructure for DeviceGroupSubmitInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_SUBMIT_INFO;
+}
 impl DeviceGroupSubmitInfo {
     pub fn builder<'a>() -> DeviceGroupSubmitInfoBuilder<'a> {
         DeviceGroupSubmitInfoBuilder {
-            inner: DeviceGroupSubmitInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18037,6 +20094,7 @@ impl<'a> ::std::ops::DerefMut for DeviceGroupSubmitInfoBuilder<'a> {
     }
 }
 impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
+    #[inline]
     pub fn wait_semaphore_device_indices(
         mut self,
         wait_semaphore_device_indices: &'a [u32],
@@ -18045,11 +20103,13 @@ impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
         self.inner.p_wait_semaphore_device_indices = wait_semaphore_device_indices.as_ptr();
         self
     }
+    #[inline]
     pub fn command_buffer_device_masks(mut self, command_buffer_device_masks: &'a [u32]) -> Self {
         self.inner.command_buffer_count = command_buffer_device_masks.len() as _;
         self.inner.p_command_buffer_device_masks = command_buffer_device_masks.as_ptr();
         self
     }
+    #[inline]
     pub fn signal_semaphore_device_indices(
         mut self,
         signal_semaphore_device_indices: &'a [u32],
@@ -18066,8 +20126,9 @@ impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupBindSparseInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupBindSparseInfo.html>"]
 pub struct DeviceGroupBindSparseInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -18075,19 +20136,23 @@ pub struct DeviceGroupBindSparseInfo {
     pub memory_device_index: u32,
 }
 impl ::std::default::Default for DeviceGroupBindSparseInfo {
-    fn default() -> DeviceGroupBindSparseInfo {
-        DeviceGroupBindSparseInfo {
-            s_type: StructureType::DEVICE_GROUP_BIND_SPARSE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             resource_device_index: u32::default(),
             memory_device_index: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DeviceGroupBindSparseInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_BIND_SPARSE_INFO;
+}
 impl DeviceGroupBindSparseInfo {
     pub fn builder<'a>() -> DeviceGroupBindSparseInfoBuilder<'a> {
         DeviceGroupBindSparseInfoBuilder {
-            inner: DeviceGroupBindSparseInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18111,10 +20176,12 @@ impl<'a> ::std::ops::DerefMut for DeviceGroupBindSparseInfoBuilder<'a> {
     }
 }
 impl<'a> DeviceGroupBindSparseInfoBuilder<'a> {
+    #[inline]
     pub fn resource_device_index(mut self, resource_device_index: u32) -> Self {
         self.inner.resource_device_index = resource_device_index;
         self
     }
+    #[inline]
     pub fn memory_device_index(mut self, memory_device_index: u32) -> Self {
         self.inner.memory_device_index = memory_device_index;
         self
@@ -18127,8 +20194,9 @@ impl<'a> DeviceGroupBindSparseInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentCapabilitiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentCapabilitiesKHR.html>"]
 pub struct DeviceGroupPresentCapabilitiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -18136,19 +20204,23 @@ pub struct DeviceGroupPresentCapabilitiesKHR {
     pub modes: DeviceGroupPresentModeFlagsKHR,
 }
 impl ::std::default::Default for DeviceGroupPresentCapabilitiesKHR {
-    fn default() -> DeviceGroupPresentCapabilitiesKHR {
-        DeviceGroupPresentCapabilitiesKHR {
-            s_type: StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             present_mask: unsafe { ::std::mem::zeroed() },
             modes: DeviceGroupPresentModeFlagsKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DeviceGroupPresentCapabilitiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_PRESENT_CAPABILITIES_KHR;
+}
 impl DeviceGroupPresentCapabilitiesKHR {
     pub fn builder<'a>() -> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
         DeviceGroupPresentCapabilitiesKHRBuilder {
-            inner: DeviceGroupPresentCapabilitiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18170,10 +20242,12 @@ impl<'a> ::std::ops::DerefMut for DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
     }
 }
 impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
+    #[inline]
     pub fn present_mask(mut self, present_mask: [u32; MAX_DEVICE_GROUP_SIZE]) -> Self {
         self.inner.present_mask = present_mask;
         self
     }
+    #[inline]
     pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self {
         self.inner.modes = modes;
         self
@@ -18186,26 +20260,31 @@ impl<'a> DeviceGroupPresentCapabilitiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSwapchainCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSwapchainCreateInfoKHR.html>"]
 pub struct ImageSwapchainCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub swapchain: SwapchainKHR,
 }
 impl ::std::default::Default for ImageSwapchainCreateInfoKHR {
-    fn default() -> ImageSwapchainCreateInfoKHR {
-        ImageSwapchainCreateInfoKHR {
-            s_type: StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             swapchain: SwapchainKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageSwapchainCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
+}
 impl ImageSwapchainCreateInfoKHR {
     pub fn builder<'a>() -> ImageSwapchainCreateInfoKHRBuilder<'a> {
         ImageSwapchainCreateInfoKHRBuilder {
-            inner: ImageSwapchainCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18229,6 +20308,7 @@ impl<'a> ::std::ops::DerefMut for ImageSwapchainCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
         self.inner.swapchain = swapchain;
         self
@@ -18241,8 +20321,9 @@ impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImageMemorySwapchainInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImageMemorySwapchainInfoKHR.html>"]
 pub struct BindImageMemorySwapchainInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -18250,19 +20331,23 @@ pub struct BindImageMemorySwapchainInfoKHR {
     pub image_index: u32,
 }
 impl ::std::default::Default for BindImageMemorySwapchainInfoKHR {
-    fn default() -> BindImageMemorySwapchainInfoKHR {
-        BindImageMemorySwapchainInfoKHR {
-            s_type: StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             swapchain: SwapchainKHR::default(),
             image_index: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for BindImageMemorySwapchainInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
+}
 impl BindImageMemorySwapchainInfoKHR {
     pub fn builder<'a>() -> BindImageMemorySwapchainInfoKHRBuilder<'a> {
         BindImageMemorySwapchainInfoKHRBuilder {
-            inner: BindImageMemorySwapchainInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18286,10 +20371,12 @@ impl<'a> ::std::ops::DerefMut for BindImageMemorySwapchainInfoKHRBuilder<'a> {
     }
 }
 impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> {
+    #[inline]
     pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
         self.inner.swapchain = swapchain;
         self
     }
+    #[inline]
     pub fn image_index(mut self, image_index: u32) -> Self {
         self.inner.image_index = image_index;
         self
@@ -18302,8 +20389,9 @@ impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireNextImageInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireNextImageInfoKHR.html>"]
 pub struct AcquireNextImageInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -18314,9 +20402,10 @@ pub struct AcquireNextImageInfoKHR {
     pub device_mask: u32,
 }
 impl ::std::default::Default for AcquireNextImageInfoKHR {
-    fn default() -> AcquireNextImageInfoKHR {
-        AcquireNextImageInfoKHR {
-            s_type: StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             swapchain: SwapchainKHR::default(),
             timeout: u64::default(),
@@ -18326,10 +20415,13 @@ impl ::std::default::Default for AcquireNextImageInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for AcquireNextImageInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::ACQUIRE_NEXT_IMAGE_INFO_KHR;
+}
 impl AcquireNextImageInfoKHR {
     pub fn builder<'a>() -> AcquireNextImageInfoKHRBuilder<'a> {
         AcquireNextImageInfoKHRBuilder {
-            inner: AcquireNextImageInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18351,22 +20443,27 @@ impl<'a> ::std::ops::DerefMut for AcquireNextImageInfoKHRBuilder<'a> {
     }
 }
 impl<'a> AcquireNextImageInfoKHRBuilder<'a> {
+    #[inline]
     pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
         self.inner.swapchain = swapchain;
         self
     }
+    #[inline]
     pub fn timeout(mut self, timeout: u64) -> Self {
         self.inner.timeout = timeout;
         self
     }
+    #[inline]
     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
         self.inner.semaphore = semaphore;
         self
     }
+    #[inline]
     pub fn fence(mut self, fence: Fence) -> Self {
         self.inner.fence = fence;
         self
     }
+    #[inline]
     pub fn device_mask(mut self, device_mask: u32) -> Self {
         self.inner.device_mask = device_mask;
         self
@@ -18379,8 +20476,9 @@ impl<'a> AcquireNextImageInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupPresentInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupPresentInfoKHR.html>"]
 pub struct DeviceGroupPresentInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -18389,9 +20487,10 @@ pub struct DeviceGroupPresentInfoKHR {
     pub mode: DeviceGroupPresentModeFlagsKHR,
 }
 impl ::std::default::Default for DeviceGroupPresentInfoKHR {
-    fn default() -> DeviceGroupPresentInfoKHR {
-        DeviceGroupPresentInfoKHR {
-            s_type: StructureType::DEVICE_GROUP_PRESENT_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             swapchain_count: u32::default(),
             p_device_masks: ::std::ptr::null(),
@@ -18399,10 +20498,13 @@ impl ::std::default::Default for DeviceGroupPresentInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for DeviceGroupPresentInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_PRESENT_INFO_KHR;
+}
 impl DeviceGroupPresentInfoKHR {
     pub fn builder<'a>() -> DeviceGroupPresentInfoKHRBuilder<'a> {
         DeviceGroupPresentInfoKHRBuilder {
-            inner: DeviceGroupPresentInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18426,11 +20528,13 @@ impl<'a> ::std::ops::DerefMut for DeviceGroupPresentInfoKHRBuilder<'a> {
     }
 }
 impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> {
+    #[inline]
     pub fn device_masks(mut self, device_masks: &'a [u32]) -> Self {
         self.inner.swapchain_count = device_masks.len() as _;
         self.inner.p_device_masks = device_masks.as_ptr();
         self
     }
+    #[inline]
     pub fn mode(mut self, mode: DeviceGroupPresentModeFlagsKHR) -> Self {
         self.inner.mode = mode;
         self
@@ -18443,8 +20547,9 @@ impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupDeviceCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupDeviceCreateInfo.html>"]
 pub struct DeviceGroupDeviceCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -18452,19 +20557,23 @@ pub struct DeviceGroupDeviceCreateInfo {
     pub p_physical_devices: *const PhysicalDevice,
 }
 impl ::std::default::Default for DeviceGroupDeviceCreateInfo {
-    fn default() -> DeviceGroupDeviceCreateInfo {
-        DeviceGroupDeviceCreateInfo {
-            s_type: StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             physical_device_count: u32::default(),
             p_physical_devices: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for DeviceGroupDeviceCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_DEVICE_CREATE_INFO;
+}
 impl DeviceGroupDeviceCreateInfo {
     pub fn builder<'a>() -> DeviceGroupDeviceCreateInfoBuilder<'a> {
         DeviceGroupDeviceCreateInfoBuilder {
-            inner: DeviceGroupDeviceCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18488,6 +20597,7 @@ impl<'a> ::std::ops::DerefMut for DeviceGroupDeviceCreateInfoBuilder<'a> {
     }
 }
 impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> {
+    #[inline]
     pub fn physical_devices(mut self, physical_devices: &'a [PhysicalDevice]) -> Self {
         self.inner.physical_device_count = physical_devices.len() as _;
         self.inner.p_physical_devices = physical_devices.as_ptr();
@@ -18501,26 +20611,31 @@ impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html>"]
 pub struct DeviceGroupSwapchainCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub modes: DeviceGroupPresentModeFlagsKHR,
 }
 impl ::std::default::Default for DeviceGroupSwapchainCreateInfoKHR {
-    fn default() -> DeviceGroupSwapchainCreateInfoKHR {
-        DeviceGroupSwapchainCreateInfoKHR {
-            s_type: StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             modes: DeviceGroupPresentModeFlagsKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DeviceGroupSwapchainCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR;
+}
 impl DeviceGroupSwapchainCreateInfoKHR {
     pub fn builder<'a>() -> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
         DeviceGroupSwapchainCreateInfoKHRBuilder {
-            inner: DeviceGroupSwapchainCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18544,6 +20659,7 @@ impl<'a> ::std::ops::DerefMut for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn modes(mut self, modes: DeviceGroupPresentModeFlagsKHR) -> Self {
         self.inner.modes = modes;
         self
@@ -18556,8 +20672,9 @@ impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateEntry.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateEntry.html>"]
 pub struct DescriptorUpdateTemplateEntry {
     pub dst_binding: u32,
     pub dst_array_element: u32,
@@ -18569,7 +20686,7 @@ pub struct DescriptorUpdateTemplateEntry {
 impl DescriptorUpdateTemplateEntry {
     pub fn builder<'a>() -> DescriptorUpdateTemplateEntryBuilder<'a> {
         DescriptorUpdateTemplateEntryBuilder {
-            inner: DescriptorUpdateTemplateEntry::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18591,26 +20708,32 @@ impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateEntryBuilder<'a> {
     }
 }
 impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> {
+    #[inline]
     pub fn dst_binding(mut self, dst_binding: u32) -> Self {
         self.inner.dst_binding = dst_binding;
         self
     }
+    #[inline]
     pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
         self.inner.dst_array_element = dst_array_element;
         self
     }
+    #[inline]
     pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
         self.inner.descriptor_count = descriptor_count;
         self
     }
+    #[inline]
     pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
         self.inner.descriptor_type = descriptor_type;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: usize) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn stride(mut self, stride: usize) -> Self {
         self.inner.stride = stride;
         self
@@ -18623,8 +20746,9 @@ impl<'a> DescriptorUpdateTemplateEntryBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateCreateInfo.html>"]
 pub struct DescriptorUpdateTemplateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -18638,9 +20762,10 @@ pub struct DescriptorUpdateTemplateCreateInfo {
     pub set: u32,
 }
 impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo {
-    fn default() -> DescriptorUpdateTemplateCreateInfo {
-        DescriptorUpdateTemplateCreateInfo {
-            s_type: StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DescriptorUpdateTemplateCreateFlags::default(),
             descriptor_update_entry_count: u32::default(),
@@ -18653,10 +20778,13 @@ impl ::std::default::Default for DescriptorUpdateTemplateCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for DescriptorUpdateTemplateCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
+}
 impl DescriptorUpdateTemplateCreateInfo {
     pub fn builder<'a>() -> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
         DescriptorUpdateTemplateCreateInfoBuilder {
-            inner: DescriptorUpdateTemplateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18678,10 +20806,12 @@ impl<'a> ::std::ops::DerefMut for DescriptorUpdateTemplateCreateInfoBuilder<'a>
     }
 }
 impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DescriptorUpdateTemplateCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn descriptor_update_entries(
         mut self,
         descriptor_update_entries: &'a [DescriptorUpdateTemplateEntry],
@@ -18690,22 +20820,27 @@ impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
         self.inner.p_descriptor_update_entries = descriptor_update_entries.as_ptr();
         self
     }
+    #[inline]
     pub fn template_type(mut self, template_type: DescriptorUpdateTemplateType) -> Self {
         self.inner.template_type = template_type;
         self
     }
+    #[inline]
     pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self {
         self.inner.descriptor_set_layout = descriptor_set_layout;
         self
     }
+    #[inline]
     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
         self.inner.pipeline_bind_point = pipeline_bind_point;
         self
     }
+    #[inline]
     pub fn pipeline_layout(mut self, pipeline_layout: PipelineLayout) -> Self {
         self.inner.pipeline_layout = pipeline_layout;
         self
     }
+    #[inline]
     pub fn set(mut self, set: u32) -> Self {
         self.inner.set = set;
         self
@@ -18718,8 +20853,9 @@ impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkXYColorEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkXYColorEXT.html>"]
 pub struct XYColorEXT {
     pub x: f32,
     pub y: f32,
@@ -18727,7 +20863,7 @@ pub struct XYColorEXT {
 impl XYColorEXT {
     pub fn builder<'a>() -> XYColorEXTBuilder<'a> {
         XYColorEXTBuilder {
-            inner: XYColorEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18749,10 +20885,12 @@ impl<'a> ::std::ops::DerefMut for XYColorEXTBuilder<'a> {
     }
 }
 impl<'a> XYColorEXTBuilder<'a> {
+    #[inline]
     pub fn x(mut self, x: f32) -> Self {
         self.inner.x = x;
         self
     }
+    #[inline]
     pub fn y(mut self, y: f32) -> Self {
         self.inner.y = y;
         self
@@ -18765,26 +20903,31 @@ impl<'a> XYColorEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html>"]
 pub struct PhysicalDevicePresentIdFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub present_id: Bool32,
 }
 impl ::std::default::Default for PhysicalDevicePresentIdFeaturesKHR {
-    fn default() -> PhysicalDevicePresentIdFeaturesKHR {
-        PhysicalDevicePresentIdFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             present_id: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePresentIdFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR;
+}
 impl PhysicalDevicePresentIdFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
         PhysicalDevicePresentIdFeaturesKHRBuilder {
-            inner: PhysicalDevicePresentIdFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18810,6 +20953,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentIdFeaturesKHRBuilder<'a>
     }
 }
 impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn present_id(mut self, present_id: bool) -> Self {
         self.inner.present_id = present_id.into();
         self
@@ -18822,8 +20966,9 @@ impl<'a> PhysicalDevicePresentIdFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentIdKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentIdKHR.html>"]
 pub struct PresentIdKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -18831,19 +20976,23 @@ pub struct PresentIdKHR {
     pub p_present_ids: *const u64,
 }
 impl ::std::default::Default for PresentIdKHR {
-    fn default() -> PresentIdKHR {
-        PresentIdKHR {
-            s_type: StructureType::PRESENT_ID_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             swapchain_count: u32::default(),
             p_present_ids: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for PresentIdKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_ID_KHR;
+}
 impl PresentIdKHR {
     pub fn builder<'a>() -> PresentIdKHRBuilder<'a> {
         PresentIdKHRBuilder {
-            inner: PresentIdKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18867,6 +21016,7 @@ impl<'a> ::std::ops::DerefMut for PresentIdKHRBuilder<'a> {
     }
 }
 impl<'a> PresentIdKHRBuilder<'a> {
+    #[inline]
     pub fn present_ids(mut self, present_ids: &'a [u64]) -> Self {
         self.inner.swapchain_count = present_ids.len() as _;
         self.inner.p_present_ids = present_ids.as_ptr();
@@ -18880,26 +21030,31 @@ impl<'a> PresentIdKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html>"]
 pub struct PhysicalDevicePresentWaitFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub present_wait: Bool32,
 }
 impl ::std::default::Default for PhysicalDevicePresentWaitFeaturesKHR {
-    fn default() -> PhysicalDevicePresentWaitFeaturesKHR {
-        PhysicalDevicePresentWaitFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             present_wait: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePresentWaitFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR;
+}
 impl PhysicalDevicePresentWaitFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
         PhysicalDevicePresentWaitFeaturesKHRBuilder {
-            inner: PhysicalDevicePresentWaitFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18925,6 +21080,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentWaitFeaturesKHRBuilder<'a
     }
 }
 impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn present_wait(mut self, present_wait: bool) -> Self {
         self.inner.present_wait = present_wait.into();
         self
@@ -18937,8 +21093,9 @@ impl<'a> PhysicalDevicePresentWaitFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHdrMetadataEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHdrMetadataEXT.html>"]
 pub struct HdrMetadataEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -18952,9 +21109,10 @@ pub struct HdrMetadataEXT {
     pub max_frame_average_light_level: f32,
 }
 impl ::std::default::Default for HdrMetadataEXT {
-    fn default() -> HdrMetadataEXT {
-        HdrMetadataEXT {
-            s_type: StructureType::HDR_METADATA_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             display_primary_red: XYColorEXT::default(),
             display_primary_green: XYColorEXT::default(),
@@ -18967,10 +21125,13 @@ impl ::std::default::Default for HdrMetadataEXT {
         }
     }
 }
+unsafe impl TaggedStructure for HdrMetadataEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::HDR_METADATA_EXT;
+}
 impl HdrMetadataEXT {
     pub fn builder<'a>() -> HdrMetadataEXTBuilder<'a> {
         HdrMetadataEXTBuilder {
-            inner: HdrMetadataEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -18992,34 +21153,42 @@ impl<'a> ::std::ops::DerefMut for HdrMetadataEXTBuilder<'a> {
     }
 }
 impl<'a> HdrMetadataEXTBuilder<'a> {
+    #[inline]
     pub fn display_primary_red(mut self, display_primary_red: XYColorEXT) -> Self {
         self.inner.display_primary_red = display_primary_red;
         self
     }
+    #[inline]
     pub fn display_primary_green(mut self, display_primary_green: XYColorEXT) -> Self {
         self.inner.display_primary_green = display_primary_green;
         self
     }
+    #[inline]
     pub fn display_primary_blue(mut self, display_primary_blue: XYColorEXT) -> Self {
         self.inner.display_primary_blue = display_primary_blue;
         self
     }
+    #[inline]
     pub fn white_point(mut self, white_point: XYColorEXT) -> Self {
         self.inner.white_point = white_point;
         self
     }
+    #[inline]
     pub fn max_luminance(mut self, max_luminance: f32) -> Self {
         self.inner.max_luminance = max_luminance;
         self
     }
+    #[inline]
     pub fn min_luminance(mut self, min_luminance: f32) -> Self {
         self.inner.min_luminance = min_luminance;
         self
     }
+    #[inline]
     pub fn max_content_light_level(mut self, max_content_light_level: f32) -> Self {
         self.inner.max_content_light_level = max_content_light_level;
         self
     }
+    #[inline]
     pub fn max_frame_average_light_level(mut self, max_frame_average_light_level: f32) -> Self {
         self.inner.max_frame_average_light_level = max_frame_average_light_level;
         self
@@ -19032,26 +21201,32 @@ impl<'a> HdrMetadataEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html>"]
 pub struct DisplayNativeHdrSurfaceCapabilitiesAMD {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub local_dimming_support: Bool32,
 }
 impl ::std::default::Default for DisplayNativeHdrSurfaceCapabilitiesAMD {
-    fn default() -> DisplayNativeHdrSurfaceCapabilitiesAMD {
-        DisplayNativeHdrSurfaceCapabilitiesAMD {
-            s_type: StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             local_dimming_support: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DisplayNativeHdrSurfaceCapabilitiesAMD {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD;
+}
 impl DisplayNativeHdrSurfaceCapabilitiesAMD {
     pub fn builder<'a>() -> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
         DisplayNativeHdrSurfaceCapabilitiesAMDBuilder {
-            inner: DisplayNativeHdrSurfaceCapabilitiesAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19075,6 +21250,7 @@ impl<'a> ::std::ops::DerefMut for DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<
     }
 }
 impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
+    #[inline]
     pub fn local_dimming_support(mut self, local_dimming_support: bool) -> Self {
         self.inner.local_dimming_support = local_dimming_support.into();
         self
@@ -19087,26 +21263,32 @@ impl<'a> DisplayNativeHdrSurfaceCapabilitiesAMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html>"]
 pub struct SwapchainDisplayNativeHdrCreateInfoAMD {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub local_dimming_enable: Bool32,
 }
 impl ::std::default::Default for SwapchainDisplayNativeHdrCreateInfoAMD {
-    fn default() -> SwapchainDisplayNativeHdrCreateInfoAMD {
-        SwapchainDisplayNativeHdrCreateInfoAMD {
-            s_type: StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             local_dimming_enable: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SwapchainDisplayNativeHdrCreateInfoAMD {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD;
+}
 impl SwapchainDisplayNativeHdrCreateInfoAMD {
     pub fn builder<'a>() -> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
         SwapchainDisplayNativeHdrCreateInfoAMDBuilder {
-            inner: SwapchainDisplayNativeHdrCreateInfoAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19130,6 +21312,7 @@ impl<'a> ::std::ops::DerefMut for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<
     }
 }
 impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
+    #[inline]
     pub fn local_dimming_enable(mut self, local_dimming_enable: bool) -> Self {
         self.inner.local_dimming_enable = local_dimming_enable.into();
         self
@@ -19142,15 +21325,16 @@ impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRefreshCycleDurationGOOGLE.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRefreshCycleDurationGOOGLE.html>"]
 pub struct RefreshCycleDurationGOOGLE {
     pub refresh_duration: u64,
 }
 impl RefreshCycleDurationGOOGLE {
     pub fn builder<'a>() -> RefreshCycleDurationGOOGLEBuilder<'a> {
         RefreshCycleDurationGOOGLEBuilder {
-            inner: RefreshCycleDurationGOOGLE::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19172,6 +21356,7 @@ impl<'a> ::std::ops::DerefMut for RefreshCycleDurationGOOGLEBuilder<'a> {
     }
 }
 impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> {
+    #[inline]
     pub fn refresh_duration(mut self, refresh_duration: u64) -> Self {
         self.inner.refresh_duration = refresh_duration;
         self
@@ -19184,8 +21369,9 @@ impl<'a> RefreshCycleDurationGOOGLEBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPastPresentationTimingGOOGLE.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPastPresentationTimingGOOGLE.html>"]
 pub struct PastPresentationTimingGOOGLE {
     pub present_id: u32,
     pub desired_present_time: u64,
@@ -19196,7 +21382,7 @@ pub struct PastPresentationTimingGOOGLE {
 impl PastPresentationTimingGOOGLE {
     pub fn builder<'a>() -> PastPresentationTimingGOOGLEBuilder<'a> {
         PastPresentationTimingGOOGLEBuilder {
-            inner: PastPresentationTimingGOOGLE::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19218,22 +21404,27 @@ impl<'a> ::std::ops::DerefMut for PastPresentationTimingGOOGLEBuilder<'a> {
     }
 }
 impl<'a> PastPresentationTimingGOOGLEBuilder<'a> {
+    #[inline]
     pub fn present_id(mut self, present_id: u32) -> Self {
         self.inner.present_id = present_id;
         self
     }
+    #[inline]
     pub fn desired_present_time(mut self, desired_present_time: u64) -> Self {
         self.inner.desired_present_time = desired_present_time;
         self
     }
+    #[inline]
     pub fn actual_present_time(mut self, actual_present_time: u64) -> Self {
         self.inner.actual_present_time = actual_present_time;
         self
     }
+    #[inline]
     pub fn earliest_present_time(mut self, earliest_present_time: u64) -> Self {
         self.inner.earliest_present_time = earliest_present_time;
         self
     }
+    #[inline]
     pub fn present_margin(mut self, present_margin: u64) -> Self {
         self.inner.present_margin = present_margin;
         self
@@ -19246,8 +21437,9 @@ impl<'a> PastPresentationTimingGOOGLEBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentTimesInfoGOOGLE.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimesInfoGOOGLE.html>"]
 pub struct PresentTimesInfoGOOGLE {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -19255,19 +21447,23 @@ pub struct PresentTimesInfoGOOGLE {
     pub p_times: *const PresentTimeGOOGLE,
 }
 impl ::std::default::Default for PresentTimesInfoGOOGLE {
-    fn default() -> PresentTimesInfoGOOGLE {
-        PresentTimesInfoGOOGLE {
-            s_type: StructureType::PRESENT_TIMES_INFO_GOOGLE,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             swapchain_count: u32::default(),
             p_times: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for PresentTimesInfoGOOGLE {
+    const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_TIMES_INFO_GOOGLE;
+}
 impl PresentTimesInfoGOOGLE {
     pub fn builder<'a>() -> PresentTimesInfoGOOGLEBuilder<'a> {
         PresentTimesInfoGOOGLEBuilder {
-            inner: PresentTimesInfoGOOGLE::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19291,6 +21487,7 @@ impl<'a> ::std::ops::DerefMut for PresentTimesInfoGOOGLEBuilder<'a> {
     }
 }
 impl<'a> PresentTimesInfoGOOGLEBuilder<'a> {
+    #[inline]
     pub fn times(mut self, times: &'a [PresentTimeGOOGLE]) -> Self {
         self.inner.swapchain_count = times.len() as _;
         self.inner.p_times = times.as_ptr();
@@ -19304,8 +21501,9 @@ impl<'a> PresentTimesInfoGOOGLEBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentTimeGOOGLE.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentTimeGOOGLE.html>"]
 pub struct PresentTimeGOOGLE {
     pub present_id: u32,
     pub desired_present_time: u64,
@@ -19313,7 +21511,7 @@ pub struct PresentTimeGOOGLE {
 impl PresentTimeGOOGLE {
     pub fn builder<'a>() -> PresentTimeGOOGLEBuilder<'a> {
         PresentTimeGOOGLEBuilder {
-            inner: PresentTimeGOOGLE::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19335,10 +21533,12 @@ impl<'a> ::std::ops::DerefMut for PresentTimeGOOGLEBuilder<'a> {
     }
 }
 impl<'a> PresentTimeGOOGLEBuilder<'a> {
+    #[inline]
     pub fn present_id(mut self, present_id: u32) -> Self {
         self.inner.present_id = present_id;
         self
     }
+    #[inline]
     pub fn desired_present_time(mut self, desired_present_time: u64) -> Self {
         self.inner.desired_present_time = desired_present_time;
         self
@@ -19351,8 +21551,9 @@ impl<'a> PresentTimeGOOGLEBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIOSSurfaceCreateInfoMVK.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIOSSurfaceCreateInfoMVK.html>"]
 pub struct IOSSurfaceCreateInfoMVK {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -19360,19 +21561,23 @@ pub struct IOSSurfaceCreateInfoMVK {
     pub p_view: *const c_void,
 }
 impl ::std::default::Default for IOSSurfaceCreateInfoMVK {
-    fn default() -> IOSSurfaceCreateInfoMVK {
-        IOSSurfaceCreateInfoMVK {
-            s_type: StructureType::IOS_SURFACE_CREATE_INFO_MVK,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: IOSSurfaceCreateFlagsMVK::default(),
             p_view: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for IOSSurfaceCreateInfoMVK {
+    const STRUCTURE_TYPE: StructureType = StructureType::IOS_SURFACE_CREATE_INFO_MVK;
+}
 impl IOSSurfaceCreateInfoMVK {
     pub fn builder<'a>() -> IOSSurfaceCreateInfoMVKBuilder<'a> {
         IOSSurfaceCreateInfoMVKBuilder {
-            inner: IOSSurfaceCreateInfoMVK::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19394,10 +21599,12 @@ impl<'a> ::std::ops::DerefMut for IOSSurfaceCreateInfoMVKBuilder<'a> {
     }
 }
 impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: IOSSurfaceCreateFlagsMVK) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn view(mut self, view: *const c_void) -> Self {
         self.inner.p_view = view;
         self
@@ -19410,8 +21617,9 @@ impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMacOSSurfaceCreateInfoMVK.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMacOSSurfaceCreateInfoMVK.html>"]
 pub struct MacOSSurfaceCreateInfoMVK {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -19419,19 +21627,23 @@ pub struct MacOSSurfaceCreateInfoMVK {
     pub p_view: *const c_void,
 }
 impl ::std::default::Default for MacOSSurfaceCreateInfoMVK {
-    fn default() -> MacOSSurfaceCreateInfoMVK {
-        MacOSSurfaceCreateInfoMVK {
-            s_type: StructureType::MACOS_SURFACE_CREATE_INFO_MVK,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: MacOSSurfaceCreateFlagsMVK::default(),
             p_view: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for MacOSSurfaceCreateInfoMVK {
+    const STRUCTURE_TYPE: StructureType = StructureType::MACOS_SURFACE_CREATE_INFO_MVK;
+}
 impl MacOSSurfaceCreateInfoMVK {
     pub fn builder<'a>() -> MacOSSurfaceCreateInfoMVKBuilder<'a> {
         MacOSSurfaceCreateInfoMVKBuilder {
-            inner: MacOSSurfaceCreateInfoMVK::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19453,10 +21665,12 @@ impl<'a> ::std::ops::DerefMut for MacOSSurfaceCreateInfoMVKBuilder<'a> {
     }
 }
 impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: MacOSSurfaceCreateFlagsMVK) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn view(mut self, view: *const c_void) -> Self {
         self.inner.p_view = view;
         self
@@ -19469,8 +21683,9 @@ impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMetalSurfaceCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMetalSurfaceCreateInfoEXT.html>"]
 pub struct MetalSurfaceCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -19478,19 +21693,23 @@ pub struct MetalSurfaceCreateInfoEXT {
     pub p_layer: *const CAMetalLayer,
 }
 impl ::std::default::Default for MetalSurfaceCreateInfoEXT {
-    fn default() -> MetalSurfaceCreateInfoEXT {
-        MetalSurfaceCreateInfoEXT {
-            s_type: StructureType::METAL_SURFACE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: MetalSurfaceCreateFlagsEXT::default(),
             p_layer: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for MetalSurfaceCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::METAL_SURFACE_CREATE_INFO_EXT;
+}
 impl MetalSurfaceCreateInfoEXT {
     pub fn builder<'a>() -> MetalSurfaceCreateInfoEXTBuilder<'a> {
         MetalSurfaceCreateInfoEXTBuilder {
-            inner: MetalSurfaceCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19512,10 +21731,12 @@ impl<'a> ::std::ops::DerefMut for MetalSurfaceCreateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: MetalSurfaceCreateFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn layer(mut self, layer: *const CAMetalLayer) -> Self {
         self.inner.p_layer = layer;
         self
@@ -19528,8 +21749,9 @@ impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewportWScalingNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportWScalingNV.html>"]
 pub struct ViewportWScalingNV {
     pub xcoeff: f32,
     pub ycoeff: f32,
@@ -19537,7 +21759,7 @@ pub struct ViewportWScalingNV {
 impl ViewportWScalingNV {
     pub fn builder<'a>() -> ViewportWScalingNVBuilder<'a> {
         ViewportWScalingNVBuilder {
-            inner: ViewportWScalingNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19559,10 +21781,12 @@ impl<'a> ::std::ops::DerefMut for ViewportWScalingNVBuilder<'a> {
     }
 }
 impl<'a> ViewportWScalingNVBuilder<'a> {
+    #[inline]
     pub fn xcoeff(mut self, xcoeff: f32) -> Self {
         self.inner.xcoeff = xcoeff;
         self
     }
+    #[inline]
     pub fn ycoeff(mut self, ycoeff: f32) -> Self {
         self.inner.ycoeff = ycoeff;
         self
@@ -19575,8 +21799,9 @@ impl<'a> ViewportWScalingNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html>"]
 pub struct PipelineViewportWScalingStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -19585,9 +21810,10 @@ pub struct PipelineViewportWScalingStateCreateInfoNV {
     pub p_viewport_w_scalings: *const ViewportWScalingNV,
 }
 impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV {
-    fn default() -> PipelineViewportWScalingStateCreateInfoNV {
-        PipelineViewportWScalingStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             viewport_w_scaling_enable: Bool32::default(),
             viewport_count: u32::default(),
@@ -19595,10 +21821,14 @@ impl ::std::default::Default for PipelineViewportWScalingStateCreateInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineViewportWScalingStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV;
+}
 impl PipelineViewportWScalingStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
         PipelineViewportWScalingStateCreateInfoNVBuilder {
-            inner: PipelineViewportWScalingStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19625,10 +21855,12 @@ impl<'a> ::std::ops::DerefMut for PipelineViewportWScalingStateCreateInfoNVBuild
     }
 }
 impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn viewport_w_scaling_enable(mut self, viewport_w_scaling_enable: bool) -> Self {
         self.inner.viewport_w_scaling_enable = viewport_w_scaling_enable.into();
         self
     }
+    #[inline]
     pub fn viewport_w_scalings(mut self, viewport_w_scalings: &'a [ViewportWScalingNV]) -> Self {
         self.inner.viewport_count = viewport_w_scalings.len() as _;
         self.inner.p_viewport_w_scalings = viewport_w_scalings.as_ptr();
@@ -19642,8 +21874,9 @@ impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewportSwizzleNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportSwizzleNV.html>"]
 pub struct ViewportSwizzleNV {
     pub x: ViewportCoordinateSwizzleNV,
     pub y: ViewportCoordinateSwizzleNV,
@@ -19653,7 +21886,7 @@ pub struct ViewportSwizzleNV {
 impl ViewportSwizzleNV {
     pub fn builder<'a>() -> ViewportSwizzleNVBuilder<'a> {
         ViewportSwizzleNVBuilder {
-            inner: ViewportSwizzleNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19675,18 +21908,22 @@ impl<'a> ::std::ops::DerefMut for ViewportSwizzleNVBuilder<'a> {
     }
 }
 impl<'a> ViewportSwizzleNVBuilder<'a> {
+    #[inline]
     pub fn x(mut self, x: ViewportCoordinateSwizzleNV) -> Self {
         self.inner.x = x;
         self
     }
+    #[inline]
     pub fn y(mut self, y: ViewportCoordinateSwizzleNV) -> Self {
         self.inner.y = y;
         self
     }
+    #[inline]
     pub fn z(mut self, z: ViewportCoordinateSwizzleNV) -> Self {
         self.inner.z = z;
         self
     }
+    #[inline]
     pub fn w(mut self, w: ViewportCoordinateSwizzleNV) -> Self {
         self.inner.w = w;
         self
@@ -19699,8 +21936,9 @@ impl<'a> ViewportSwizzleNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html>"]
 pub struct PipelineViewportSwizzleStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -19709,9 +21947,10 @@ pub struct PipelineViewportSwizzleStateCreateInfoNV {
     pub p_viewport_swizzles: *const ViewportSwizzleNV,
 }
 impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV {
-    fn default() -> PipelineViewportSwizzleStateCreateInfoNV {
-        PipelineViewportSwizzleStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineViewportSwizzleStateCreateFlagsNV::default(),
             viewport_count: u32::default(),
@@ -19719,10 +21958,14 @@ impl ::std::default::Default for PipelineViewportSwizzleStateCreateInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineViewportSwizzleStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV;
+}
 impl PipelineViewportSwizzleStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
         PipelineViewportSwizzleStateCreateInfoNVBuilder {
-            inner: PipelineViewportSwizzleStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19749,10 +21992,12 @@ impl<'a> ::std::ops::DerefMut for PipelineViewportSwizzleStateCreateInfoNVBuilde
     }
 }
 impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineViewportSwizzleStateCreateFlagsNV) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn viewport_swizzles(mut self, viewport_swizzles: &'a [ViewportSwizzleNV]) -> Self {
         self.inner.viewport_count = viewport_swizzles.len() as _;
         self.inner.p_viewport_swizzles = viewport_swizzles.as_ptr();
@@ -19766,26 +22011,32 @@ impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html>"]
 pub struct PhysicalDeviceDiscardRectanglePropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_discard_rectangles: u32,
 }
 impl ::std::default::Default for PhysicalDeviceDiscardRectanglePropertiesEXT {
-    fn default() -> PhysicalDeviceDiscardRectanglePropertiesEXT {
-        PhysicalDeviceDiscardRectanglePropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_discard_rectangles: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDiscardRectanglePropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT;
+}
 impl PhysicalDeviceDiscardRectanglePropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
         PhysicalDeviceDiscardRectanglePropertiesEXTBuilder {
-            inner: PhysicalDeviceDiscardRectanglePropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19812,6 +22063,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiscardRectanglePropertiesEXTBui
     }
 }
 impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn max_discard_rectangles(mut self, max_discard_rectangles: u32) -> Self {
         self.inner.max_discard_rectangles = max_discard_rectangles;
         self
@@ -19824,8 +22076,9 @@ impl<'a> PhysicalDeviceDiscardRectanglePropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html>"]
 pub struct PipelineDiscardRectangleStateCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -19835,9 +22088,10 @@ pub struct PipelineDiscardRectangleStateCreateInfoEXT {
     pub p_discard_rectangles: *const Rect2D,
 }
 impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT {
-    fn default() -> PipelineDiscardRectangleStateCreateInfoEXT {
-        PipelineDiscardRectangleStateCreateInfoEXT {
-            s_type: StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineDiscardRectangleStateCreateFlagsEXT::default(),
             discard_rectangle_mode: DiscardRectangleModeEXT::default(),
@@ -19846,10 +22100,14 @@ impl ::std::default::Default for PipelineDiscardRectangleStateCreateInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineDiscardRectangleStateCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT;
+}
 impl PipelineDiscardRectangleStateCreateInfoEXT {
     pub fn builder<'a>() -> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
         PipelineDiscardRectangleStateCreateInfoEXTBuilder {
-            inner: PipelineDiscardRectangleStateCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19876,10 +22134,12 @@ impl<'a> ::std::ops::DerefMut for PipelineDiscardRectangleStateCreateInfoEXTBuil
     }
 }
 impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineDiscardRectangleStateCreateFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn discard_rectangle_mode(
         mut self,
         discard_rectangle_mode: DiscardRectangleModeEXT,
@@ -19887,6 +22147,7 @@ impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
         self.inner.discard_rectangle_mode = discard_rectangle_mode;
         self
     }
+    #[inline]
     pub fn discard_rectangles(mut self, discard_rectangles: &'a [Rect2D]) -> Self {
         self.inner.discard_rectangle_count = discard_rectangles.len() as _;
         self.inner.p_discard_rectangles = discard_rectangles.as_ptr();
@@ -19900,26 +22161,32 @@ impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html>"]
 pub struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub per_view_position_all_components: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
-    fn default() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
-        PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
-            s_type: StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             per_view_position_all_components: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX;
+}
 impl PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
     pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
         PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder {
-            inner: PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19949,6 +22216,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewAttributesProper
     }
 }
 impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
+    #[inline]
     pub fn per_view_position_all_components(
         mut self,
         per_view_position_all_components: bool,
@@ -19964,8 +22232,9 @@ impl<'a> PhysicalDeviceMultiviewPerViewAttributesPropertiesNVXBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInputAttachmentAspectReference.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInputAttachmentAspectReference.html>"]
 pub struct InputAttachmentAspectReference {
     pub subpass: u32,
     pub input_attachment_index: u32,
@@ -19974,7 +22243,7 @@ pub struct InputAttachmentAspectReference {
 impl InputAttachmentAspectReference {
     pub fn builder<'a>() -> InputAttachmentAspectReferenceBuilder<'a> {
         InputAttachmentAspectReferenceBuilder {
-            inner: InputAttachmentAspectReference::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -19996,14 +22265,17 @@ impl<'a> ::std::ops::DerefMut for InputAttachmentAspectReferenceBuilder<'a> {
     }
 }
 impl<'a> InputAttachmentAspectReferenceBuilder<'a> {
+    #[inline]
     pub fn subpass(mut self, subpass: u32) -> Self {
         self.inner.subpass = subpass;
         self
     }
+    #[inline]
     pub fn input_attachment_index(mut self, input_attachment_index: u32) -> Self {
         self.inner.input_attachment_index = input_attachment_index;
         self
     }
+    #[inline]
     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
         self.inner.aspect_mask = aspect_mask;
         self
@@ -20016,8 +22288,9 @@ impl<'a> InputAttachmentAspectReferenceBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html>"]
 pub struct RenderPassInputAttachmentAspectCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -20025,19 +22298,24 @@ pub struct RenderPassInputAttachmentAspectCreateInfo {
     pub p_aspect_references: *const InputAttachmentAspectReference,
 }
 impl ::std::default::Default for RenderPassInputAttachmentAspectCreateInfo {
-    fn default() -> RenderPassInputAttachmentAspectCreateInfo {
-        RenderPassInputAttachmentAspectCreateInfo {
-            s_type: StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             aspect_reference_count: u32::default(),
             p_aspect_references: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for RenderPassInputAttachmentAspectCreateInfo {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
+}
 impl RenderPassInputAttachmentAspectCreateInfo {
     pub fn builder<'a>() -> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
         RenderPassInputAttachmentAspectCreateInfoBuilder {
-            inner: RenderPassInputAttachmentAspectCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20061,6 +22339,7 @@ impl<'a> ::std::ops::DerefMut for RenderPassInputAttachmentAspectCreateInfoBuild
     }
 }
 impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
+    #[inline]
     pub fn aspect_references(
         mut self,
         aspect_references: &'a [InputAttachmentAspectReference],
@@ -20077,26 +22356,31 @@ impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html>"]
 pub struct PhysicalDeviceSurfaceInfo2KHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub surface: SurfaceKHR,
 }
 impl ::std::default::Default for PhysicalDeviceSurfaceInfo2KHR {
-    fn default() -> PhysicalDeviceSurfaceInfo2KHR {
-        PhysicalDeviceSurfaceInfo2KHR {
-            s_type: StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             surface: SurfaceKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceSurfaceInfo2KHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
+}
 impl PhysicalDeviceSurfaceInfo2KHR {
     pub fn builder<'a>() -> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
         PhysicalDeviceSurfaceInfo2KHRBuilder {
-            inner: PhysicalDeviceSurfaceInfo2KHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20119,6 +22403,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
+    #[inline]
     pub fn surface(mut self, surface: SurfaceKHR) -> Self {
         self.inner.surface = surface;
         self
@@ -20130,10 +22415,10 @@ impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsPhysicalDeviceSurfaceInfo2KHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -20145,26 +22430,31 @@ impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilities2KHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilities2KHR.html>"]
 pub struct SurfaceCapabilities2KHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub surface_capabilities: SurfaceCapabilitiesKHR,
 }
 impl ::std::default::Default for SurfaceCapabilities2KHR {
-    fn default() -> SurfaceCapabilities2KHR {
-        SurfaceCapabilities2KHR {
-            s_type: StructureType::SURFACE_CAPABILITIES_2_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             surface_capabilities: SurfaceCapabilitiesKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SurfaceCapabilities2KHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_2_KHR;
+}
 impl SurfaceCapabilities2KHR {
     pub fn builder<'a>() -> SurfaceCapabilities2KHRBuilder<'a> {
         SurfaceCapabilities2KHRBuilder {
-            inner: SurfaceCapabilities2KHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20187,6 +22477,7 @@ impl<'a> ::std::ops::DerefMut for SurfaceCapabilities2KHRBuilder<'a> {
     }
 }
 impl<'a> SurfaceCapabilities2KHRBuilder<'a> {
+    #[inline]
     pub fn surface_capabilities(mut self, surface_capabilities: SurfaceCapabilitiesKHR) -> Self {
         self.inner.surface_capabilities = surface_capabilities;
         self
@@ -20198,10 +22489,10 @@ impl<'a> SurfaceCapabilities2KHRBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsSurfaceCapabilities2KHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -20213,26 +22504,31 @@ impl<'a> SurfaceCapabilities2KHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFormat2KHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFormat2KHR.html>"]
 pub struct SurfaceFormat2KHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub surface_format: SurfaceFormatKHR,
 }
 impl ::std::default::Default for SurfaceFormat2KHR {
-    fn default() -> SurfaceFormat2KHR {
-        SurfaceFormat2KHR {
-            s_type: StructureType::SURFACE_FORMAT_2_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             surface_format: SurfaceFormatKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SurfaceFormat2KHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_FORMAT_2_KHR;
+}
 impl SurfaceFormat2KHR {
     pub fn builder<'a>() -> SurfaceFormat2KHRBuilder<'a> {
         SurfaceFormat2KHRBuilder {
-            inner: SurfaceFormat2KHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20242,6 +22538,7 @@ pub struct SurfaceFormat2KHRBuilder<'a> {
     inner: SurfaceFormat2KHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+pub unsafe trait ExtendsSurfaceFormat2KHR {}
 impl<'a> ::std::ops::Deref for SurfaceFormat2KHRBuilder<'a> {
     type Target = SurfaceFormat2KHR;
     fn deref(&self) -> &Self::Target {
@@ -20254,10 +22551,25 @@ impl<'a> ::std::ops::DerefMut for SurfaceFormat2KHRBuilder<'a> {
     }
 }
 impl<'a> SurfaceFormat2KHRBuilder<'a> {
+    #[inline]
     pub fn surface_format(mut self, surface_format: SurfaceFormatKHR) -> Self {
         self.inner.surface_format = surface_format;
         self
     }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsSurfaceFormat2KHR>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*mut T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
@@ -20266,26 +22578,31 @@ impl<'a> SurfaceFormat2KHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayProperties2KHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayProperties2KHR.html>"]
 pub struct DisplayProperties2KHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub display_properties: DisplayPropertiesKHR,
 }
 impl ::std::default::Default for DisplayProperties2KHR {
-    fn default() -> DisplayProperties2KHR {
-        DisplayProperties2KHR {
-            s_type: StructureType::DISPLAY_PROPERTIES_2_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             display_properties: DisplayPropertiesKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DisplayProperties2KHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PROPERTIES_2_KHR;
+}
 impl DisplayProperties2KHR {
     pub fn builder<'a>() -> DisplayProperties2KHRBuilder<'a> {
         DisplayProperties2KHRBuilder {
-            inner: DisplayProperties2KHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20307,6 +22624,7 @@ impl<'a> ::std::ops::DerefMut for DisplayProperties2KHRBuilder<'a> {
     }
 }
 impl<'a> DisplayProperties2KHRBuilder<'a> {
+    #[inline]
     pub fn display_properties(mut self, display_properties: DisplayPropertiesKHR) -> Self {
         self.inner.display_properties = display_properties;
         self
@@ -20319,26 +22637,31 @@ impl<'a> DisplayProperties2KHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneProperties2KHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneProperties2KHR.html>"]
 pub struct DisplayPlaneProperties2KHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub display_plane_properties: DisplayPlanePropertiesKHR,
 }
 impl ::std::default::Default for DisplayPlaneProperties2KHR {
-    fn default() -> DisplayPlaneProperties2KHR {
-        DisplayPlaneProperties2KHR {
-            s_type: StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             display_plane_properties: DisplayPlanePropertiesKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DisplayPlaneProperties2KHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_PROPERTIES_2_KHR;
+}
 impl DisplayPlaneProperties2KHR {
     pub fn builder<'a>() -> DisplayPlaneProperties2KHRBuilder<'a> {
         DisplayPlaneProperties2KHRBuilder {
-            inner: DisplayPlaneProperties2KHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20360,6 +22683,7 @@ impl<'a> ::std::ops::DerefMut for DisplayPlaneProperties2KHRBuilder<'a> {
     }
 }
 impl<'a> DisplayPlaneProperties2KHRBuilder<'a> {
+    #[inline]
     pub fn display_plane_properties(
         mut self,
         display_plane_properties: DisplayPlanePropertiesKHR,
@@ -20375,26 +22699,31 @@ impl<'a> DisplayPlaneProperties2KHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayModeProperties2KHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayModeProperties2KHR.html>"]
 pub struct DisplayModeProperties2KHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub display_mode_properties: DisplayModePropertiesKHR,
 }
 impl ::std::default::Default for DisplayModeProperties2KHR {
-    fn default() -> DisplayModeProperties2KHR {
-        DisplayModeProperties2KHR {
-            s_type: StructureType::DISPLAY_MODE_PROPERTIES_2_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             display_mode_properties: DisplayModePropertiesKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DisplayModeProperties2KHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_MODE_PROPERTIES_2_KHR;
+}
 impl DisplayModeProperties2KHR {
     pub fn builder<'a>() -> DisplayModeProperties2KHRBuilder<'a> {
         DisplayModeProperties2KHRBuilder {
-            inner: DisplayModeProperties2KHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20416,6 +22745,7 @@ impl<'a> ::std::ops::DerefMut for DisplayModeProperties2KHRBuilder<'a> {
     }
 }
 impl<'a> DisplayModeProperties2KHRBuilder<'a> {
+    #[inline]
     pub fn display_mode_properties(
         mut self,
         display_mode_properties: DisplayModePropertiesKHR,
@@ -20431,8 +22761,9 @@ impl<'a> DisplayModeProperties2KHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneInfo2KHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneInfo2KHR.html>"]
 pub struct DisplayPlaneInfo2KHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -20440,19 +22771,23 @@ pub struct DisplayPlaneInfo2KHR {
     pub plane_index: u32,
 }
 impl ::std::default::Default for DisplayPlaneInfo2KHR {
-    fn default() -> DisplayPlaneInfo2KHR {
-        DisplayPlaneInfo2KHR {
-            s_type: StructureType::DISPLAY_PLANE_INFO_2_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             mode: DisplayModeKHR::default(),
             plane_index: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DisplayPlaneInfo2KHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_INFO_2_KHR;
+}
 impl DisplayPlaneInfo2KHR {
     pub fn builder<'a>() -> DisplayPlaneInfo2KHRBuilder<'a> {
         DisplayPlaneInfo2KHRBuilder {
-            inner: DisplayPlaneInfo2KHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20474,10 +22809,12 @@ impl<'a> ::std::ops::DerefMut for DisplayPlaneInfo2KHRBuilder<'a> {
     }
 }
 impl<'a> DisplayPlaneInfo2KHRBuilder<'a> {
+    #[inline]
     pub fn mode(mut self, mode: DisplayModeKHR) -> Self {
         self.inner.mode = mode;
         self
     }
+    #[inline]
     pub fn plane_index(mut self, plane_index: u32) -> Self {
         self.inner.plane_index = plane_index;
         self
@@ -20490,26 +22827,31 @@ impl<'a> DisplayPlaneInfo2KHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPlaneCapabilities2KHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPlaneCapabilities2KHR.html>"]
 pub struct DisplayPlaneCapabilities2KHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub capabilities: DisplayPlaneCapabilitiesKHR,
 }
 impl ::std::default::Default for DisplayPlaneCapabilities2KHR {
-    fn default() -> DisplayPlaneCapabilities2KHR {
-        DisplayPlaneCapabilities2KHR {
-            s_type: StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             capabilities: DisplayPlaneCapabilitiesKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DisplayPlaneCapabilities2KHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::DISPLAY_PLANE_CAPABILITIES_2_KHR;
+}
 impl DisplayPlaneCapabilities2KHR {
     pub fn builder<'a>() -> DisplayPlaneCapabilities2KHRBuilder<'a> {
         DisplayPlaneCapabilities2KHRBuilder {
-            inner: DisplayPlaneCapabilities2KHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20531,6 +22873,7 @@ impl<'a> ::std::ops::DerefMut for DisplayPlaneCapabilities2KHRBuilder<'a> {
     }
 }
 impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> {
+    #[inline]
     pub fn capabilities(mut self, capabilities: DisplayPlaneCapabilitiesKHR) -> Self {
         self.inner.capabilities = capabilities;
         self
@@ -20543,26 +22886,31 @@ impl<'a> DisplayPlaneCapabilities2KHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html>"]
 pub struct SharedPresentSurfaceCapabilitiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shared_present_supported_usage_flags: ImageUsageFlags,
 }
 impl ::std::default::Default for SharedPresentSurfaceCapabilitiesKHR {
-    fn default() -> SharedPresentSurfaceCapabilitiesKHR {
-        SharedPresentSurfaceCapabilitiesKHR {
-            s_type: StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shared_present_supported_usage_flags: ImageUsageFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SharedPresentSurfaceCapabilitiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::SHARED_PRESENT_SURFACE_CAPABILITIES_KHR;
+}
 impl SharedPresentSurfaceCapabilitiesKHR {
     pub fn builder<'a>() -> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
         SharedPresentSurfaceCapabilitiesKHRBuilder {
-            inner: SharedPresentSurfaceCapabilitiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20586,6 +22934,7 @@ impl<'a> ::std::ops::DerefMut for SharedPresentSurfaceCapabilitiesKHRBuilder<'a>
     }
 }
 impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
+    #[inline]
     pub fn shared_present_supported_usage_flags(
         mut self,
         shared_present_supported_usage_flags: ImageUsageFlags,
@@ -20601,8 +22950,9 @@ impl<'a> SharedPresentSurfaceCapabilitiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice16BitStorageFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice16BitStorageFeatures.html>"]
 pub struct PhysicalDevice16BitStorageFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -20612,9 +22962,10 @@ pub struct PhysicalDevice16BitStorageFeatures {
     pub storage_input_output16: Bool32,
 }
 impl ::std::default::Default for PhysicalDevice16BitStorageFeatures {
-    fn default() -> PhysicalDevice16BitStorageFeatures {
-        PhysicalDevice16BitStorageFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             storage_buffer16_bit_access: Bool32::default(),
             uniform_and_storage_buffer16_bit_access: Bool32::default(),
@@ -20623,10 +22974,13 @@ impl ::std::default::Default for PhysicalDevice16BitStorageFeatures {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevice16BitStorageFeatures {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
+}
 impl PhysicalDevice16BitStorageFeatures {
     pub fn builder<'a>() -> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
         PhysicalDevice16BitStorageFeaturesBuilder {
-            inner: PhysicalDevice16BitStorageFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20652,10 +23006,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevice16BitStorageFeaturesBuilder<'a>
     }
 }
 impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
+    #[inline]
     pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
         self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
         self
     }
+    #[inline]
     pub fn uniform_and_storage_buffer16_bit_access(
         mut self,
         uniform_and_storage_buffer16_bit_access: bool,
@@ -20664,10 +23020,12 @@ impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
             uniform_and_storage_buffer16_bit_access.into();
         self
     }
+    #[inline]
     pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
         self.inner.storage_push_constant16 = storage_push_constant16.into();
         self
     }
+    #[inline]
     pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
         self.inner.storage_input_output16 = storage_input_output16.into();
         self
@@ -20680,8 +23038,9 @@ impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupProperties.html>"]
 pub struct PhysicalDeviceSubgroupProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -20691,9 +23050,10 @@ pub struct PhysicalDeviceSubgroupProperties {
     pub quad_operations_in_all_stages: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceSubgroupProperties {
-    fn default() -> PhysicalDeviceSubgroupProperties {
-        PhysicalDeviceSubgroupProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             subgroup_size: u32::default(),
             supported_stages: ShaderStageFlags::default(),
@@ -20702,10 +23062,13 @@ impl ::std::default::Default for PhysicalDeviceSubgroupProperties {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceSubgroupProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
+}
 impl PhysicalDeviceSubgroupProperties {
     pub fn builder<'a>() -> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
         PhysicalDeviceSubgroupPropertiesBuilder {
-            inner: PhysicalDeviceSubgroupProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20729,18 +23092,22 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupPropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
+    #[inline]
     pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
         self.inner.subgroup_size = subgroup_size;
         self
     }
+    #[inline]
     pub fn supported_stages(mut self, supported_stages: ShaderStageFlags) -> Self {
         self.inner.supported_stages = supported_stages;
         self
     }
+    #[inline]
     pub fn supported_operations(mut self, supported_operations: SubgroupFeatureFlags) -> Self {
         self.inner.supported_operations = supported_operations;
         self
     }
+    #[inline]
     pub fn quad_operations_in_all_stages(mut self, quad_operations_in_all_stages: bool) -> Self {
         self.inner.quad_operations_in_all_stages = quad_operations_in_all_stages.into();
         self
@@ -20753,26 +23120,32 @@ impl<'a> PhysicalDeviceSubgroupPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html>"]
 pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shader_subgroup_extended_types: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
-    fn default() -> PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
-        PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_subgroup_extended_types: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
+}
 impl PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
     pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
         PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder {
-            inner: PhysicalDeviceShaderSubgroupExtendedTypesFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20804,6 +23177,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSubgroupExtendedTypesFeatu
     }
 }
 impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
+    #[inline]
     pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
         self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
         self
@@ -20816,26 +23190,31 @@ impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferMemoryRequirementsInfo2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryRequirementsInfo2.html>"]
 pub struct BufferMemoryRequirementsInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub buffer: Buffer,
 }
 impl ::std::default::Default for BufferMemoryRequirementsInfo2 {
-    fn default() -> BufferMemoryRequirementsInfo2 {
-        BufferMemoryRequirementsInfo2 {
-            s_type: StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             buffer: Buffer::default(),
         }
     }
 }
+unsafe impl TaggedStructure for BufferMemoryRequirementsInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_REQUIREMENTS_INFO_2;
+}
 impl BufferMemoryRequirementsInfo2 {
     pub fn builder<'a>() -> BufferMemoryRequirementsInfo2Builder<'a> {
         BufferMemoryRequirementsInfo2Builder {
-            inner: BufferMemoryRequirementsInfo2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20857,6 +23236,7 @@ impl<'a> ::std::ops::DerefMut for BufferMemoryRequirementsInfo2Builder<'a> {
     }
 }
 impl<'a> BufferMemoryRequirementsInfo2Builder<'a> {
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
@@ -20869,26 +23249,90 @@ impl<'a> BufferMemoryRequirementsInfo2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageMemoryRequirementsInfo2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceBufferMemoryRequirements.html>"]
+pub struct DeviceBufferMemoryRequirements {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub p_create_info: *const BufferCreateInfo,
+}
+impl ::std::default::Default for DeviceBufferMemoryRequirements {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            p_create_info: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DeviceBufferMemoryRequirements {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_BUFFER_MEMORY_REQUIREMENTS;
+}
+impl DeviceBufferMemoryRequirements {
+    pub fn builder<'a>() -> DeviceBufferMemoryRequirementsBuilder<'a> {
+        DeviceBufferMemoryRequirementsBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DeviceBufferMemoryRequirementsBuilder<'a> {
+    inner: DeviceBufferMemoryRequirements,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DeviceBufferMemoryRequirementsBuilder<'a> {
+    type Target = DeviceBufferMemoryRequirements;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DeviceBufferMemoryRequirementsBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DeviceBufferMemoryRequirementsBuilder<'a> {
+    #[inline]
+    pub fn create_info(mut self, create_info: &'a BufferCreateInfo) -> Self {
+        self.inner.p_create_info = create_info;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DeviceBufferMemoryRequirements {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryRequirementsInfo2.html>"]
 pub struct ImageMemoryRequirementsInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub image: Image,
 }
 impl ::std::default::Default for ImageMemoryRequirementsInfo2 {
-    fn default() -> ImageMemoryRequirementsInfo2 {
-        ImageMemoryRequirementsInfo2 {
-            s_type: StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             image: Image::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageMemoryRequirementsInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_REQUIREMENTS_INFO_2;
+}
 impl ImageMemoryRequirementsInfo2 {
     pub fn builder<'a>() -> ImageMemoryRequirementsInfo2Builder<'a> {
         ImageMemoryRequirementsInfo2Builder {
-            inner: ImageMemoryRequirementsInfo2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20911,6 +23355,7 @@ impl<'a> ::std::ops::DerefMut for ImageMemoryRequirementsInfo2Builder<'a> {
     }
 }
 impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
@@ -20922,10 +23367,10 @@ impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsImageMemoryRequirementsInfo2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -20937,26 +23382,31 @@ impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageSparseMemoryRequirementsInfo2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSparseMemoryRequirementsInfo2.html>"]
 pub struct ImageSparseMemoryRequirementsInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub image: Image,
 }
 impl ::std::default::Default for ImageSparseMemoryRequirementsInfo2 {
-    fn default() -> ImageSparseMemoryRequirementsInfo2 {
-        ImageSparseMemoryRequirementsInfo2 {
-            s_type: StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             image: Image::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageSparseMemoryRequirementsInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
+}
 impl ImageSparseMemoryRequirementsInfo2 {
     pub fn builder<'a>() -> ImageSparseMemoryRequirementsInfo2Builder<'a> {
         ImageSparseMemoryRequirementsInfo2Builder {
-            inner: ImageSparseMemoryRequirementsInfo2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -20978,6 +23428,7 @@ impl<'a> ::std::ops::DerefMut for ImageSparseMemoryRequirementsInfo2Builder<'a>
     }
 }
 impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> {
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
@@ -20990,26 +23441,97 @@ impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryRequirements2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceImageMemoryRequirements.html>"]
+pub struct DeviceImageMemoryRequirements {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub p_create_info: *const ImageCreateInfo,
+    pub plane_aspect: ImageAspectFlags,
+}
+impl ::std::default::Default for DeviceImageMemoryRequirements {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            p_create_info: ::std::ptr::null(),
+            plane_aspect: ImageAspectFlags::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DeviceImageMemoryRequirements {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_IMAGE_MEMORY_REQUIREMENTS;
+}
+impl DeviceImageMemoryRequirements {
+    pub fn builder<'a>() -> DeviceImageMemoryRequirementsBuilder<'a> {
+        DeviceImageMemoryRequirementsBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DeviceImageMemoryRequirementsBuilder<'a> {
+    inner: DeviceImageMemoryRequirements,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DeviceImageMemoryRequirementsBuilder<'a> {
+    type Target = DeviceImageMemoryRequirements;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DeviceImageMemoryRequirementsBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DeviceImageMemoryRequirementsBuilder<'a> {
+    #[inline]
+    pub fn create_info(mut self, create_info: &'a ImageCreateInfo) -> Self {
+        self.inner.p_create_info = create_info;
+        self
+    }
+    #[inline]
+    pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
+        self.inner.plane_aspect = plane_aspect;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DeviceImageMemoryRequirements {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryRequirements2.html>"]
 pub struct MemoryRequirements2 {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub memory_requirements: MemoryRequirements,
 }
 impl ::std::default::Default for MemoryRequirements2 {
-    fn default() -> MemoryRequirements2 {
-        MemoryRequirements2 {
-            s_type: StructureType::MEMORY_REQUIREMENTS_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             memory_requirements: MemoryRequirements::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryRequirements2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_REQUIREMENTS_2;
+}
 impl MemoryRequirements2 {
     pub fn builder<'a>() -> MemoryRequirements2Builder<'a> {
         MemoryRequirements2Builder {
-            inner: MemoryRequirements2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21032,6 +23554,7 @@ impl<'a> ::std::ops::DerefMut for MemoryRequirements2Builder<'a> {
     }
 }
 impl<'a> MemoryRequirements2Builder<'a> {
+    #[inline]
     pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self {
         self.inner.memory_requirements = memory_requirements;
         self
@@ -21043,10 +23566,10 @@ impl<'a> MemoryRequirements2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsMemoryRequirements2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -21058,26 +23581,31 @@ impl<'a> MemoryRequirements2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSparseImageMemoryRequirements2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSparseImageMemoryRequirements2.html>"]
 pub struct SparseImageMemoryRequirements2 {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub memory_requirements: SparseImageMemoryRequirements,
 }
 impl ::std::default::Default for SparseImageMemoryRequirements2 {
-    fn default() -> SparseImageMemoryRequirements2 {
-        SparseImageMemoryRequirements2 {
-            s_type: StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             memory_requirements: SparseImageMemoryRequirements::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SparseImageMemoryRequirements2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
+}
 impl SparseImageMemoryRequirements2 {
     pub fn builder<'a>() -> SparseImageMemoryRequirements2Builder<'a> {
         SparseImageMemoryRequirements2Builder {
-            inner: SparseImageMemoryRequirements2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21099,6 +23627,7 @@ impl<'a> ::std::ops::DerefMut for SparseImageMemoryRequirements2Builder<'a> {
     }
 }
 impl<'a> SparseImageMemoryRequirements2Builder<'a> {
+    #[inline]
     pub fn memory_requirements(
         mut self,
         memory_requirements: SparseImageMemoryRequirements,
@@ -21114,26 +23643,31 @@ impl<'a> SparseImageMemoryRequirements2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePointClippingProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePointClippingProperties.html>"]
 pub struct PhysicalDevicePointClippingProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub point_clipping_behavior: PointClippingBehavior,
 }
 impl ::std::default::Default for PhysicalDevicePointClippingProperties {
-    fn default() -> PhysicalDevicePointClippingProperties {
-        PhysicalDevicePointClippingProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             point_clipping_behavior: PointClippingBehavior::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePointClippingProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
+}
 impl PhysicalDevicePointClippingProperties {
     pub fn builder<'a>() -> PhysicalDevicePointClippingPropertiesBuilder<'a> {
         PhysicalDevicePointClippingPropertiesBuilder {
-            inner: PhysicalDevicePointClippingProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21157,6 +23691,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePointClippingPropertiesBuilder<'
     }
 }
 impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> {
+    #[inline]
     pub fn point_clipping_behavior(
         mut self,
         point_clipping_behavior: PointClippingBehavior,
@@ -21172,8 +23707,9 @@ impl<'a> PhysicalDevicePointClippingPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryDedicatedRequirements.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedRequirements.html>"]
 pub struct MemoryDedicatedRequirements {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -21181,19 +23717,23 @@ pub struct MemoryDedicatedRequirements {
     pub requires_dedicated_allocation: Bool32,
 }
 impl ::std::default::Default for MemoryDedicatedRequirements {
-    fn default() -> MemoryDedicatedRequirements {
-        MemoryDedicatedRequirements {
-            s_type: StructureType::MEMORY_DEDICATED_REQUIREMENTS,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             prefers_dedicated_allocation: Bool32::default(),
             requires_dedicated_allocation: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryDedicatedRequirements {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_DEDICATED_REQUIREMENTS;
+}
 impl MemoryDedicatedRequirements {
     pub fn builder<'a>() -> MemoryDedicatedRequirementsBuilder<'a> {
         MemoryDedicatedRequirementsBuilder {
-            inner: MemoryDedicatedRequirements::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21217,10 +23757,12 @@ impl<'a> ::std::ops::DerefMut for MemoryDedicatedRequirementsBuilder<'a> {
     }
 }
 impl<'a> MemoryDedicatedRequirementsBuilder<'a> {
+    #[inline]
     pub fn prefers_dedicated_allocation(mut self, prefers_dedicated_allocation: bool) -> Self {
         self.inner.prefers_dedicated_allocation = prefers_dedicated_allocation.into();
         self
     }
+    #[inline]
     pub fn requires_dedicated_allocation(mut self, requires_dedicated_allocation: bool) -> Self {
         self.inner.requires_dedicated_allocation = requires_dedicated_allocation.into();
         self
@@ -21233,8 +23775,9 @@ impl<'a> MemoryDedicatedRequirementsBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryDedicatedAllocateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryDedicatedAllocateInfo.html>"]
 pub struct MemoryDedicatedAllocateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -21242,19 +23785,23 @@ pub struct MemoryDedicatedAllocateInfo {
     pub buffer: Buffer,
 }
 impl ::std::default::Default for MemoryDedicatedAllocateInfo {
-    fn default() -> MemoryDedicatedAllocateInfo {
-        MemoryDedicatedAllocateInfo {
-            s_type: StructureType::MEMORY_DEDICATED_ALLOCATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             image: Image::default(),
             buffer: Buffer::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryDedicatedAllocateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_DEDICATED_ALLOCATE_INFO;
+}
 impl MemoryDedicatedAllocateInfo {
     pub fn builder<'a>() -> MemoryDedicatedAllocateInfoBuilder<'a> {
         MemoryDedicatedAllocateInfoBuilder {
-            inner: MemoryDedicatedAllocateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21278,10 +23825,12 @@ impl<'a> ::std::ops::DerefMut for MemoryDedicatedAllocateInfoBuilder<'a> {
     }
 }
 impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> {
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
     }
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
@@ -21294,26 +23843,31 @@ impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewUsageCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewUsageCreateInfo.html>"]
 pub struct ImageViewUsageCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub usage: ImageUsageFlags,
 }
 impl ::std::default::Default for ImageViewUsageCreateInfo {
-    fn default() -> ImageViewUsageCreateInfo {
-        ImageViewUsageCreateInfo {
-            s_type: StructureType::IMAGE_VIEW_USAGE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             usage: ImageUsageFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageViewUsageCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_USAGE_CREATE_INFO;
+}
 impl ImageViewUsageCreateInfo {
     pub fn builder<'a>() -> ImageViewUsageCreateInfoBuilder<'a> {
         ImageViewUsageCreateInfoBuilder {
-            inner: ImageViewUsageCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21337,6 +23891,7 @@ impl<'a> ::std::ops::DerefMut for ImageViewUsageCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ImageViewUsageCreateInfoBuilder<'a> {
+    #[inline]
     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
         self.inner.usage = usage;
         self
@@ -21349,26 +23904,100 @@ impl<'a> ImageViewUsageCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewSlicedCreateInfoEXT.html>"]
+pub struct ImageViewSlicedCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub slice_offset: u32,
+    pub slice_count: u32,
+}
+impl ::std::default::Default for ImageViewSlicedCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            slice_offset: u32::default(),
+            slice_count: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageViewSlicedCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_SLICED_CREATE_INFO_EXT;
+}
+impl ImageViewSlicedCreateInfoEXT {
+    pub fn builder<'a>() -> ImageViewSlicedCreateInfoEXTBuilder<'a> {
+        ImageViewSlicedCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageViewSlicedCreateInfoEXTBuilder<'a> {
+    inner: ImageViewSlicedCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsImageViewCreateInfo for ImageViewSlicedCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsImageViewCreateInfo for ImageViewSlicedCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for ImageViewSlicedCreateInfoEXTBuilder<'a> {
+    type Target = ImageViewSlicedCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageViewSlicedCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageViewSlicedCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn slice_offset(mut self, slice_offset: u32) -> Self {
+        self.inner.slice_offset = slice_offset;
+        self
+    }
+    #[inline]
+    pub fn slice_count(mut self, slice_count: u32) -> Self {
+        self.inner.slice_count = slice_count;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageViewSlicedCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html>"]
 pub struct PipelineTessellationDomainOriginStateCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub domain_origin: TessellationDomainOrigin,
 }
 impl ::std::default::Default for PipelineTessellationDomainOriginStateCreateInfo {
-    fn default() -> PipelineTessellationDomainOriginStateCreateInfo {
-        PipelineTessellationDomainOriginStateCreateInfo {
-            s_type: StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             domain_origin: TessellationDomainOrigin::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineTessellationDomainOriginStateCreateInfo {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
+}
 impl PipelineTessellationDomainOriginStateCreateInfo {
     pub fn builder<'a>() -> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
         PipelineTessellationDomainOriginStateCreateInfoBuilder {
-            inner: PipelineTessellationDomainOriginStateCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21398,6 +24027,7 @@ impl<'a> ::std::ops::DerefMut for PipelineTessellationDomainOriginStateCreateInf
     }
 }
 impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
+    #[inline]
     pub fn domain_origin(mut self, domain_origin: TessellationDomainOrigin) -> Self {
         self.inner.domain_origin = domain_origin;
         self
@@ -21410,26 +24040,31 @@ impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversionInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionInfo.html>"]
 pub struct SamplerYcbcrConversionInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub conversion: SamplerYcbcrConversion,
 }
 impl ::std::default::Default for SamplerYcbcrConversionInfo {
-    fn default() -> SamplerYcbcrConversionInfo {
-        SamplerYcbcrConversionInfo {
-            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             conversion: SamplerYcbcrConversion::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SamplerYcbcrConversionInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_YCBCR_CONVERSION_INFO;
+}
 impl SamplerYcbcrConversionInfo {
     pub fn builder<'a>() -> SamplerYcbcrConversionInfoBuilder<'a> {
         SamplerYcbcrConversionInfoBuilder {
-            inner: SamplerYcbcrConversionInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21455,6 +24090,7 @@ impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionInfoBuilder<'a> {
     }
 }
 impl<'a> SamplerYcbcrConversionInfoBuilder<'a> {
+    #[inline]
     pub fn conversion(mut self, conversion: SamplerYcbcrConversion) -> Self {
         self.inner.conversion = conversion;
         self
@@ -21467,8 +24103,9 @@ impl<'a> SamplerYcbcrConversionInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversionCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionCreateInfo.html>"]
 pub struct SamplerYcbcrConversionCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -21482,9 +24119,10 @@ pub struct SamplerYcbcrConversionCreateInfo {
     pub force_explicit_reconstruction: Bool32,
 }
 impl ::std::default::Default for SamplerYcbcrConversionCreateInfo {
-    fn default() -> SamplerYcbcrConversionCreateInfo {
-        SamplerYcbcrConversionCreateInfo {
-            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             format: Format::default(),
             ycbcr_model: SamplerYcbcrModelConversion::default(),
@@ -21497,10 +24135,13 @@ impl ::std::default::Default for SamplerYcbcrConversionCreateInfo {
         }
     }
 }
+unsafe impl TaggedStructure for SamplerYcbcrConversionCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
+}
 impl SamplerYcbcrConversionCreateInfo {
     pub fn builder<'a>() -> SamplerYcbcrConversionCreateInfoBuilder<'a> {
         SamplerYcbcrConversionCreateInfoBuilder {
-            inner: SamplerYcbcrConversionCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21523,34 +24164,42 @@ impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionCreateInfoBuilder<'a> {
     }
 }
 impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn ycbcr_model(mut self, ycbcr_model: SamplerYcbcrModelConversion) -> Self {
         self.inner.ycbcr_model = ycbcr_model;
         self
     }
+    #[inline]
     pub fn ycbcr_range(mut self, ycbcr_range: SamplerYcbcrRange) -> Self {
         self.inner.ycbcr_range = ycbcr_range;
         self
     }
+    #[inline]
     pub fn components(mut self, components: ComponentMapping) -> Self {
         self.inner.components = components;
         self
     }
+    #[inline]
     pub fn x_chroma_offset(mut self, x_chroma_offset: ChromaLocation) -> Self {
         self.inner.x_chroma_offset = x_chroma_offset;
         self
     }
+    #[inline]
     pub fn y_chroma_offset(mut self, y_chroma_offset: ChromaLocation) -> Self {
         self.inner.y_chroma_offset = y_chroma_offset;
         self
     }
+    #[inline]
     pub fn chroma_filter(mut self, chroma_filter: Filter) -> Self {
         self.inner.chroma_filter = chroma_filter;
         self
     }
+    #[inline]
     pub fn force_explicit_reconstruction(mut self, force_explicit_reconstruction: bool) -> Self {
         self.inner.force_explicit_reconstruction = force_explicit_reconstruction.into();
         self
@@ -21565,10 +24214,10 @@ impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -21580,26 +24229,31 @@ impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindImagePlaneMemoryInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindImagePlaneMemoryInfo.html>"]
 pub struct BindImagePlaneMemoryInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub plane_aspect: ImageAspectFlags,
 }
 impl ::std::default::Default for BindImagePlaneMemoryInfo {
-    fn default() -> BindImagePlaneMemoryInfo {
-        BindImagePlaneMemoryInfo {
-            s_type: StructureType::BIND_IMAGE_PLANE_MEMORY_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             plane_aspect: ImageAspectFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for BindImagePlaneMemoryInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BIND_IMAGE_PLANE_MEMORY_INFO;
+}
 impl BindImagePlaneMemoryInfo {
     pub fn builder<'a>() -> BindImagePlaneMemoryInfoBuilder<'a> {
         BindImagePlaneMemoryInfoBuilder {
-            inner: BindImagePlaneMemoryInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21623,6 +24277,7 @@ impl<'a> ::std::ops::DerefMut for BindImagePlaneMemoryInfoBuilder<'a> {
     }
 }
 impl<'a> BindImagePlaneMemoryInfoBuilder<'a> {
+    #[inline]
     pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
         self.inner.plane_aspect = plane_aspect;
         self
@@ -21635,26 +24290,31 @@ impl<'a> BindImagePlaneMemoryInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImagePlaneMemoryRequirementsInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImagePlaneMemoryRequirementsInfo.html>"]
 pub struct ImagePlaneMemoryRequirementsInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub plane_aspect: ImageAspectFlags,
 }
 impl ::std::default::Default for ImagePlaneMemoryRequirementsInfo {
-    fn default() -> ImagePlaneMemoryRequirementsInfo {
-        ImagePlaneMemoryRequirementsInfo {
-            s_type: StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             plane_aspect: ImageAspectFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImagePlaneMemoryRequirementsInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
+}
 impl ImagePlaneMemoryRequirementsInfo {
     pub fn builder<'a>() -> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
         ImagePlaneMemoryRequirementsInfoBuilder {
-            inner: ImagePlaneMemoryRequirementsInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21678,6 +24338,7 @@ impl<'a> ::std::ops::DerefMut for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
     }
 }
 impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
+    #[inline]
     pub fn plane_aspect(mut self, plane_aspect: ImageAspectFlags) -> Self {
         self.inner.plane_aspect = plane_aspect;
         self
@@ -21690,26 +24351,32 @@ impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html>"]
 pub struct PhysicalDeviceSamplerYcbcrConversionFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub sampler_ycbcr_conversion: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceSamplerYcbcrConversionFeatures {
-    fn default() -> PhysicalDeviceSamplerYcbcrConversionFeatures {
-        PhysicalDeviceSamplerYcbcrConversionFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             sampler_ycbcr_conversion: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceSamplerYcbcrConversionFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+}
 impl PhysicalDeviceSamplerYcbcrConversionFeatures {
     pub fn builder<'a>() -> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
         PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder {
-            inner: PhysicalDeviceSamplerYcbcrConversionFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21738,6 +24405,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerYcbcrConversionFeaturesBu
     }
 }
 impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
+    #[inline]
     pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
         self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
         self
@@ -21750,26 +24418,32 @@ impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrConversionImageFormatProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrConversionImageFormatProperties.html>"]
 pub struct SamplerYcbcrConversionImageFormatProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub combined_image_sampler_descriptor_count: u32,
 }
 impl ::std::default::Default for SamplerYcbcrConversionImageFormatProperties {
-    fn default() -> SamplerYcbcrConversionImageFormatProperties {
-        SamplerYcbcrConversionImageFormatProperties {
-            s_type: StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             combined_image_sampler_descriptor_count: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SamplerYcbcrConversionImageFormatProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
+}
 impl SamplerYcbcrConversionImageFormatProperties {
     pub fn builder<'a>() -> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
         SamplerYcbcrConversionImageFormatPropertiesBuilder {
-            inner: SamplerYcbcrConversionImageFormatProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21796,6 +24470,7 @@ impl<'a> ::std::ops::DerefMut for SamplerYcbcrConversionImageFormatPropertiesBui
     }
 }
 impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
+    #[inline]
     pub fn combined_image_sampler_descriptor_count(
         mut self,
         combined_image_sampler_descriptor_count: u32,
@@ -21812,26 +24487,31 @@ impl<'a> SamplerYcbcrConversionImageFormatPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTextureLODGatherFormatPropertiesAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTextureLODGatherFormatPropertiesAMD.html>"]
 pub struct TextureLODGatherFormatPropertiesAMD {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub supports_texture_gather_lod_bias_amd: Bool32,
 }
 impl ::std::default::Default for TextureLODGatherFormatPropertiesAMD {
-    fn default() -> TextureLODGatherFormatPropertiesAMD {
-        TextureLODGatherFormatPropertiesAMD {
-            s_type: StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             supports_texture_gather_lod_bias_amd: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for TextureLODGatherFormatPropertiesAMD {
+    const STRUCTURE_TYPE: StructureType = StructureType::TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD;
+}
 impl TextureLODGatherFormatPropertiesAMD {
     pub fn builder<'a>() -> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
         TextureLODGatherFormatPropertiesAMDBuilder {
-            inner: TextureLODGatherFormatPropertiesAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21855,6 +24535,7 @@ impl<'a> ::std::ops::DerefMut for TextureLODGatherFormatPropertiesAMDBuilder<'a>
     }
 }
 impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
+    #[inline]
     pub fn supports_texture_gather_lod_bias_amd(
         mut self,
         supports_texture_gather_lod_bias_amd: bool,
@@ -21871,8 +24552,9 @@ impl<'a> TextureLODGatherFormatPropertiesAMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConditionalRenderingBeginInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConditionalRenderingBeginInfoEXT.html>"]
 pub struct ConditionalRenderingBeginInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -21881,9 +24563,10 @@ pub struct ConditionalRenderingBeginInfoEXT {
     pub flags: ConditionalRenderingFlagsEXT,
 }
 impl ::std::default::Default for ConditionalRenderingBeginInfoEXT {
-    fn default() -> ConditionalRenderingBeginInfoEXT {
-        ConditionalRenderingBeginInfoEXT {
-            s_type: StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             buffer: Buffer::default(),
             offset: DeviceSize::default(),
@@ -21891,10 +24574,13 @@ impl ::std::default::Default for ConditionalRenderingBeginInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for ConditionalRenderingBeginInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::CONDITIONAL_RENDERING_BEGIN_INFO_EXT;
+}
 impl ConditionalRenderingBeginInfoEXT {
     pub fn builder<'a>() -> ConditionalRenderingBeginInfoEXTBuilder<'a> {
         ConditionalRenderingBeginInfoEXTBuilder {
-            inner: ConditionalRenderingBeginInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21916,14 +24602,17 @@ impl<'a> ::std::ops::DerefMut for ConditionalRenderingBeginInfoEXTBuilder<'a> {
     }
 }
 impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> {
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: ConditionalRenderingFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
@@ -21936,26 +24625,31 @@ impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkProtectedSubmitInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkProtectedSubmitInfo.html>"]
 pub struct ProtectedSubmitInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub protected_submit: Bool32,
 }
 impl ::std::default::Default for ProtectedSubmitInfo {
-    fn default() -> ProtectedSubmitInfo {
-        ProtectedSubmitInfo {
-            s_type: StructureType::PROTECTED_SUBMIT_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             protected_submit: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ProtectedSubmitInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PROTECTED_SUBMIT_INFO;
+}
 impl ProtectedSubmitInfo {
     pub fn builder<'a>() -> ProtectedSubmitInfoBuilder<'a> {
         ProtectedSubmitInfoBuilder {
-            inner: ProtectedSubmitInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -21979,6 +24673,7 @@ impl<'a> ::std::ops::DerefMut for ProtectedSubmitInfoBuilder<'a> {
     }
 }
 impl<'a> ProtectedSubmitInfoBuilder<'a> {
+    #[inline]
     pub fn protected_submit(mut self, protected_submit: bool) -> Self {
         self.inner.protected_submit = protected_submit.into();
         self
@@ -21991,26 +24686,31 @@ impl<'a> ProtectedSubmitInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html>"]
 pub struct PhysicalDeviceProtectedMemoryFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub protected_memory: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceProtectedMemoryFeatures {
-    fn default() -> PhysicalDeviceProtectedMemoryFeatures {
-        PhysicalDeviceProtectedMemoryFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             protected_memory: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceProtectedMemoryFeatures {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES;
+}
 impl PhysicalDeviceProtectedMemoryFeatures {
     pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
         PhysicalDeviceProtectedMemoryFeaturesBuilder {
-            inner: PhysicalDeviceProtectedMemoryFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22036,6 +24736,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryFeaturesBuilder<'
     }
 }
 impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
+    #[inline]
     pub fn protected_memory(mut self, protected_memory: bool) -> Self {
         self.inner.protected_memory = protected_memory.into();
         self
@@ -22048,26 +24749,32 @@ impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProtectedMemoryProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProtectedMemoryProperties.html>"]
 pub struct PhysicalDeviceProtectedMemoryProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub protected_no_fault: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceProtectedMemoryProperties {
-    fn default() -> PhysicalDeviceProtectedMemoryProperties {
-        PhysicalDeviceProtectedMemoryProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             protected_no_fault: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceProtectedMemoryProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES;
+}
 impl PhysicalDeviceProtectedMemoryProperties {
     pub fn builder<'a>() -> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
         PhysicalDeviceProtectedMemoryPropertiesBuilder {
-            inner: PhysicalDeviceProtectedMemoryProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22094,6 +24801,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceProtectedMemoryPropertiesBuilder
     }
 }
 impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
+    #[inline]
     pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
         self.inner.protected_no_fault = protected_no_fault.into();
         self
@@ -22106,8 +24814,9 @@ impl<'a> PhysicalDeviceProtectedMemoryPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueInfo2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueInfo2.html>"]
 pub struct DeviceQueueInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -22116,9 +24825,10 @@ pub struct DeviceQueueInfo2 {
     pub queue_index: u32,
 }
 impl ::std::default::Default for DeviceQueueInfo2 {
-    fn default() -> DeviceQueueInfo2 {
-        DeviceQueueInfo2 {
-            s_type: StructureType::DEVICE_QUEUE_INFO_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DeviceQueueCreateFlags::default(),
             queue_family_index: u32::default(),
@@ -22126,10 +24836,13 @@ impl ::std::default::Default for DeviceQueueInfo2 {
         }
     }
 }
+unsafe impl TaggedStructure for DeviceQueueInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_QUEUE_INFO_2;
+}
 impl DeviceQueueInfo2 {
     pub fn builder<'a>() -> DeviceQueueInfo2Builder<'a> {
         DeviceQueueInfo2Builder {
-            inner: DeviceQueueInfo2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22151,14 +24864,17 @@ impl<'a> ::std::ops::DerefMut for DeviceQueueInfo2Builder<'a> {
     }
 }
 impl<'a> DeviceQueueInfo2Builder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DeviceQueueCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
         self.inner.queue_family_index = queue_family_index;
         self
     }
+    #[inline]
     pub fn queue_index(mut self, queue_index: u32) -> Self {
         self.inner.queue_index = queue_index;
         self
@@ -22171,8 +24887,9 @@ impl<'a> DeviceQueueInfo2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html>"]
 pub struct PipelineCoverageToColorStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -22181,9 +24898,10 @@ pub struct PipelineCoverageToColorStateCreateInfoNV {
     pub coverage_to_color_location: u32,
 }
 impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV {
-    fn default() -> PipelineCoverageToColorStateCreateInfoNV {
-        PipelineCoverageToColorStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineCoverageToColorStateCreateFlagsNV::default(),
             coverage_to_color_enable: Bool32::default(),
@@ -22191,10 +24909,14 @@ impl ::std::default::Default for PipelineCoverageToColorStateCreateInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineCoverageToColorStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV;
+}
 impl PipelineCoverageToColorStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
         PipelineCoverageToColorStateCreateInfoNVBuilder {
-            inner: PipelineCoverageToColorStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22221,14 +24943,17 @@ impl<'a> ::std::ops::DerefMut for PipelineCoverageToColorStateCreateInfoNVBuilde
     }
 }
 impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineCoverageToColorStateCreateFlagsNV) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self {
         self.inner.coverage_to_color_enable = coverage_to_color_enable.into();
         self
     }
+    #[inline]
     pub fn coverage_to_color_location(mut self, coverage_to_color_location: u32) -> Self {
         self.inner.coverage_to_color_location = coverage_to_color_location;
         self
@@ -22241,8 +24966,9 @@ impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html>"]
 pub struct PhysicalDeviceSamplerFilterMinmaxProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -22250,19 +24976,24 @@ pub struct PhysicalDeviceSamplerFilterMinmaxProperties {
     pub filter_minmax_image_component_mapping: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceSamplerFilterMinmaxProperties {
-    fn default() -> PhysicalDeviceSamplerFilterMinmaxProperties {
-        PhysicalDeviceSamplerFilterMinmaxProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             filter_minmax_single_component_formats: Bool32::default(),
             filter_minmax_image_component_mapping: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceSamplerFilterMinmaxProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
+}
 impl PhysicalDeviceSamplerFilterMinmaxProperties {
     pub fn builder<'a>() -> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
         PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder {
-            inner: PhysicalDeviceSamplerFilterMinmaxProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22289,6 +25020,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSamplerFilterMinmaxPropertiesBui
     }
 }
 impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
+    #[inline]
     pub fn filter_minmax_single_component_formats(
         mut self,
         filter_minmax_single_component_formats: bool,
@@ -22297,6 +25029,7 @@ impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
             filter_minmax_single_component_formats.into();
         self
     }
+    #[inline]
     pub fn filter_minmax_image_component_mapping(
         mut self,
         filter_minmax_image_component_mapping: bool,
@@ -22313,8 +25046,9 @@ impl<'a> PhysicalDeviceSamplerFilterMinmaxPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleLocationEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationEXT.html>"]
 pub struct SampleLocationEXT {
     pub x: f32,
     pub y: f32,
@@ -22322,7 +25056,7 @@ pub struct SampleLocationEXT {
 impl SampleLocationEXT {
     pub fn builder<'a>() -> SampleLocationEXTBuilder<'a> {
         SampleLocationEXTBuilder {
-            inner: SampleLocationEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22344,10 +25078,12 @@ impl<'a> ::std::ops::DerefMut for SampleLocationEXTBuilder<'a> {
     }
 }
 impl<'a> SampleLocationEXTBuilder<'a> {
+    #[inline]
     pub fn x(mut self, x: f32) -> Self {
         self.inner.x = x;
         self
     }
+    #[inline]
     pub fn y(mut self, y: f32) -> Self {
         self.inner.y = y;
         self
@@ -22360,8 +25096,9 @@ impl<'a> SampleLocationEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSampleLocationsInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSampleLocationsInfoEXT.html>"]
 pub struct SampleLocationsInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -22371,9 +25108,10 @@ pub struct SampleLocationsInfoEXT {
     pub p_sample_locations: *const SampleLocationEXT,
 }
 impl ::std::default::Default for SampleLocationsInfoEXT {
-    fn default() -> SampleLocationsInfoEXT {
-        SampleLocationsInfoEXT {
-            s_type: StructureType::SAMPLE_LOCATIONS_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             sample_locations_per_pixel: SampleCountFlags::default(),
             sample_location_grid_size: Extent2D::default(),
@@ -22382,10 +25120,13 @@ impl ::std::default::Default for SampleLocationsInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for SampleLocationsInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SAMPLE_LOCATIONS_INFO_EXT;
+}
 impl SampleLocationsInfoEXT {
     pub fn builder<'a>() -> SampleLocationsInfoEXTBuilder<'a> {
         SampleLocationsInfoEXTBuilder {
-            inner: SampleLocationsInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22397,8 +25138,8 @@ pub struct SampleLocationsInfoEXTBuilder<'a> {
 }
 unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXTBuilder<'_> {}
 unsafe impl ExtendsImageMemoryBarrier for SampleLocationsInfoEXT {}
-unsafe impl ExtendsImageMemoryBarrier2KHR for SampleLocationsInfoEXTBuilder<'_> {}
-unsafe impl ExtendsImageMemoryBarrier2KHR for SampleLocationsInfoEXT {}
+unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXTBuilder<'_> {}
+unsafe impl ExtendsImageMemoryBarrier2 for SampleLocationsInfoEXT {}
 impl<'a> ::std::ops::Deref for SampleLocationsInfoEXTBuilder<'a> {
     type Target = SampleLocationsInfoEXT;
     fn deref(&self) -> &Self::Target {
@@ -22411,6 +25152,7 @@ impl<'a> ::std::ops::DerefMut for SampleLocationsInfoEXTBuilder<'a> {
     }
 }
 impl<'a> SampleLocationsInfoEXTBuilder<'a> {
+    #[inline]
     pub fn sample_locations_per_pixel(
         mut self,
         sample_locations_per_pixel: SampleCountFlags,
@@ -22418,10 +25160,12 @@ impl<'a> SampleLocationsInfoEXTBuilder<'a> {
         self.inner.sample_locations_per_pixel = sample_locations_per_pixel;
         self
     }
+    #[inline]
     pub fn sample_location_grid_size(mut self, sample_location_grid_size: Extent2D) -> Self {
         self.inner.sample_location_grid_size = sample_location_grid_size;
         self
     }
+    #[inline]
     pub fn sample_locations(mut self, sample_locations: &'a [SampleLocationEXT]) -> Self {
         self.inner.sample_locations_count = sample_locations.len() as _;
         self.inner.p_sample_locations = sample_locations.as_ptr();
@@ -22435,8 +25179,9 @@ impl<'a> SampleLocationsInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentSampleLocationsEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleLocationsEXT.html>"]
 pub struct AttachmentSampleLocationsEXT {
     pub attachment_index: u32,
     pub sample_locations_info: SampleLocationsInfoEXT,
@@ -22444,7 +25189,7 @@ pub struct AttachmentSampleLocationsEXT {
 impl AttachmentSampleLocationsEXT {
     pub fn builder<'a>() -> AttachmentSampleLocationsEXTBuilder<'a> {
         AttachmentSampleLocationsEXTBuilder {
-            inner: AttachmentSampleLocationsEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22466,10 +25211,12 @@ impl<'a> ::std::ops::DerefMut for AttachmentSampleLocationsEXTBuilder<'a> {
     }
 }
 impl<'a> AttachmentSampleLocationsEXTBuilder<'a> {
+    #[inline]
     pub fn attachment_index(mut self, attachment_index: u32) -> Self {
         self.inner.attachment_index = attachment_index;
         self
     }
+    #[inline]
     pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
         self.inner.sample_locations_info = sample_locations_info;
         self
@@ -22482,8 +25229,9 @@ impl<'a> AttachmentSampleLocationsEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassSampleLocationsEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassSampleLocationsEXT.html>"]
 pub struct SubpassSampleLocationsEXT {
     pub subpass_index: u32,
     pub sample_locations_info: SampleLocationsInfoEXT,
@@ -22491,7 +25239,7 @@ pub struct SubpassSampleLocationsEXT {
 impl SubpassSampleLocationsEXT {
     pub fn builder<'a>() -> SubpassSampleLocationsEXTBuilder<'a> {
         SubpassSampleLocationsEXTBuilder {
-            inner: SubpassSampleLocationsEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22513,10 +25261,12 @@ impl<'a> ::std::ops::DerefMut for SubpassSampleLocationsEXTBuilder<'a> {
     }
 }
 impl<'a> SubpassSampleLocationsEXTBuilder<'a> {
+    #[inline]
     pub fn subpass_index(mut self, subpass_index: u32) -> Self {
         self.inner.subpass_index = subpass_index;
         self
     }
+    #[inline]
     pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
         self.inner.sample_locations_info = sample_locations_info;
         self
@@ -22529,8 +25279,9 @@ impl<'a> SubpassSampleLocationsEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html>"]
 pub struct RenderPassSampleLocationsBeginInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -22540,9 +25291,10 @@ pub struct RenderPassSampleLocationsBeginInfoEXT {
     pub p_post_subpass_sample_locations: *const SubpassSampleLocationsEXT,
 }
 impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT {
-    fn default() -> RenderPassSampleLocationsBeginInfoEXT {
-        RenderPassSampleLocationsBeginInfoEXT {
-            s_type: StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             attachment_initial_sample_locations_count: u32::default(),
             p_attachment_initial_sample_locations: ::std::ptr::null(),
@@ -22551,10 +25303,14 @@ impl ::std::default::Default for RenderPassSampleLocationsBeginInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for RenderPassSampleLocationsBeginInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT;
+}
 impl RenderPassSampleLocationsBeginInfoEXT {
     pub fn builder<'a>() -> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
         RenderPassSampleLocationsBeginInfoEXTBuilder {
-            inner: RenderPassSampleLocationsBeginInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22578,6 +25334,7 @@ impl<'a> ::std::ops::DerefMut for RenderPassSampleLocationsBeginInfoEXTBuilder<'
     }
 }
 impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
+    #[inline]
     pub fn attachment_initial_sample_locations(
         mut self,
         attachment_initial_sample_locations: &'a [AttachmentSampleLocationsEXT],
@@ -22588,6 +25345,7 @@ impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
             attachment_initial_sample_locations.as_ptr();
         self
     }
+    #[inline]
     pub fn post_subpass_sample_locations(
         mut self,
         post_subpass_sample_locations: &'a [SubpassSampleLocationsEXT],
@@ -22604,8 +25362,9 @@ impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html>"]
 pub struct PipelineSampleLocationsStateCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -22613,19 +25372,24 @@ pub struct PipelineSampleLocationsStateCreateInfoEXT {
     pub sample_locations_info: SampleLocationsInfoEXT,
 }
 impl ::std::default::Default for PipelineSampleLocationsStateCreateInfoEXT {
-    fn default() -> PipelineSampleLocationsStateCreateInfoEXT {
-        PipelineSampleLocationsStateCreateInfoEXT {
-            s_type: StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             sample_locations_enable: Bool32::default(),
             sample_locations_info: SampleLocationsInfoEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineSampleLocationsStateCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT;
+}
 impl PipelineSampleLocationsStateCreateInfoEXT {
     pub fn builder<'a>() -> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
         PipelineSampleLocationsStateCreateInfoEXTBuilder {
-            inner: PipelineSampleLocationsStateCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22655,10 +25419,12 @@ impl<'a> ::std::ops::DerefMut for PipelineSampleLocationsStateCreateInfoEXTBuild
     }
 }
 impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn sample_locations_enable(mut self, sample_locations_enable: bool) -> Self {
         self.inner.sample_locations_enable = sample_locations_enable.into();
         self
     }
+    #[inline]
     pub fn sample_locations_info(mut self, sample_locations_info: SampleLocationsInfoEXT) -> Self {
         self.inner.sample_locations_info = sample_locations_info;
         self
@@ -22671,8 +25437,9 @@ impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html>"]
 pub struct PhysicalDeviceSampleLocationsPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -22683,9 +25450,10 @@ pub struct PhysicalDeviceSampleLocationsPropertiesEXT {
     pub variable_sample_locations: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT {
-    fn default() -> PhysicalDeviceSampleLocationsPropertiesEXT {
-        PhysicalDeviceSampleLocationsPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             sample_location_sample_counts: SampleCountFlags::default(),
             max_sample_location_grid_size: Extent2D::default(),
@@ -22695,10 +25463,14 @@ impl ::std::default::Default for PhysicalDeviceSampleLocationsPropertiesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceSampleLocationsPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT;
+}
 impl PhysicalDeviceSampleLocationsPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
         PhysicalDeviceSampleLocationsPropertiesEXTBuilder {
-            inner: PhysicalDeviceSampleLocationsPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22725,6 +25497,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSampleLocationsPropertiesEXTBuil
     }
 }
 impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn sample_location_sample_counts(
         mut self,
         sample_location_sample_counts: SampleCountFlags,
@@ -22732,6 +25505,7 @@ impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
         self.inner.sample_location_sample_counts = sample_location_sample_counts;
         self
     }
+    #[inline]
     pub fn max_sample_location_grid_size(
         mut self,
         max_sample_location_grid_size: Extent2D,
@@ -22739,6 +25513,7 @@ impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
         self.inner.max_sample_location_grid_size = max_sample_location_grid_size;
         self
     }
+    #[inline]
     pub fn sample_location_coordinate_range(
         mut self,
         sample_location_coordinate_range: [f32; 2],
@@ -22746,10 +25521,12 @@ impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
         self.inner.sample_location_coordinate_range = sample_location_coordinate_range;
         self
     }
+    #[inline]
     pub fn sample_location_sub_pixel_bits(mut self, sample_location_sub_pixel_bits: u32) -> Self {
         self.inner.sample_location_sub_pixel_bits = sample_location_sub_pixel_bits;
         self
     }
+    #[inline]
     pub fn variable_sample_locations(mut self, variable_sample_locations: bool) -> Self {
         self.inner.variable_sample_locations = variable_sample_locations.into();
         self
@@ -22762,26 +25539,31 @@ impl<'a> PhysicalDeviceSampleLocationsPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMultisamplePropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultisamplePropertiesEXT.html>"]
 pub struct MultisamplePropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_sample_location_grid_size: Extent2D,
 }
 impl ::std::default::Default for MultisamplePropertiesEXT {
-    fn default() -> MultisamplePropertiesEXT {
-        MultisamplePropertiesEXT {
-            s_type: StructureType::MULTISAMPLE_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_sample_location_grid_size: Extent2D::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MultisamplePropertiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::MULTISAMPLE_PROPERTIES_EXT;
+}
 impl MultisamplePropertiesEXT {
     pub fn builder<'a>() -> MultisamplePropertiesEXTBuilder<'a> {
         MultisamplePropertiesEXTBuilder {
-            inner: MultisamplePropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22803,6 +25585,7 @@ impl<'a> ::std::ops::DerefMut for MultisamplePropertiesEXTBuilder<'a> {
     }
 }
 impl<'a> MultisamplePropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn max_sample_location_grid_size(
         mut self,
         max_sample_location_grid_size: Extent2D,
@@ -22818,26 +25601,31 @@ impl<'a> MultisamplePropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerReductionModeCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerReductionModeCreateInfo.html>"]
 pub struct SamplerReductionModeCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub reduction_mode: SamplerReductionMode,
 }
 impl ::std::default::Default for SamplerReductionModeCreateInfo {
-    fn default() -> SamplerReductionModeCreateInfo {
-        SamplerReductionModeCreateInfo {
-            s_type: StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             reduction_mode: SamplerReductionMode::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SamplerReductionModeCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_REDUCTION_MODE_CREATE_INFO;
+}
 impl SamplerReductionModeCreateInfo {
     pub fn builder<'a>() -> SamplerReductionModeCreateInfoBuilder<'a> {
         SamplerReductionModeCreateInfoBuilder {
-            inner: SamplerReductionModeCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22861,6 +25649,7 @@ impl<'a> ::std::ops::DerefMut for SamplerReductionModeCreateInfoBuilder<'a> {
     }
 }
 impl<'a> SamplerReductionModeCreateInfoBuilder<'a> {
+    #[inline]
     pub fn reduction_mode(mut self, reduction_mode: SamplerReductionMode) -> Self {
         self.inner.reduction_mode = reduction_mode;
         self
@@ -22873,26 +25662,32 @@ impl<'a> SamplerReductionModeCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html>"]
 pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub advanced_blend_coherent_operations: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
-    fn default() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
-        PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             advanced_blend_coherent_operations: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
+}
 impl PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
         PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder {
-            inner: PhysicalDeviceBlendOperationAdvancedFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22921,6 +25716,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedFeaturesEX
     }
 }
 impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn advanced_blend_coherent_operations(
         mut self,
         advanced_blend_coherent_operations: bool,
@@ -22936,26 +25732,31 @@ impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html>"]
 pub struct PhysicalDeviceMultiDrawFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub multi_draw: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceMultiDrawFeaturesEXT {
-    fn default() -> PhysicalDeviceMultiDrawFeaturesEXT {
-        PhysicalDeviceMultiDrawFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             multi_draw: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMultiDrawFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT;
+}
 impl PhysicalDeviceMultiDrawFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
         PhysicalDeviceMultiDrawFeaturesEXTBuilder {
-            inner: PhysicalDeviceMultiDrawFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -22981,6 +25782,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a>
     }
 }
 impl<'a> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn multi_draw(mut self, multi_draw: bool) -> Self {
         self.inner.multi_draw = multi_draw.into();
         self
@@ -22993,8 +25795,9 @@ impl<'a> PhysicalDeviceMultiDrawFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html>"]
 pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -23006,9 +25809,10 @@ pub struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
     pub advanced_blend_all_operations: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
-    fn default() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
-        PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             advanced_blend_max_color_attachments: u32::default(),
             advanced_blend_independent_blend: Bool32::default(),
@@ -23019,10 +25823,14 @@ impl ::std::default::Default for PhysicalDeviceBlendOperationAdvancedPropertiesE
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
+}
 impl PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
         PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder {
-            inner: PhysicalDeviceBlendOperationAdvancedPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23049,6 +25857,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceBlendOperationAdvancedProperties
     }
 }
 impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn advanced_blend_max_color_attachments(
         mut self,
         advanced_blend_max_color_attachments: u32,
@@ -23056,6 +25865,7 @@ impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
         self.inner.advanced_blend_max_color_attachments = advanced_blend_max_color_attachments;
         self
     }
+    #[inline]
     pub fn advanced_blend_independent_blend(
         mut self,
         advanced_blend_independent_blend: bool,
@@ -23063,6 +25873,7 @@ impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
         self.inner.advanced_blend_independent_blend = advanced_blend_independent_blend.into();
         self
     }
+    #[inline]
     pub fn advanced_blend_non_premultiplied_src_color(
         mut self,
         advanced_blend_non_premultiplied_src_color: bool,
@@ -23071,6 +25882,7 @@ impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
             advanced_blend_non_premultiplied_src_color.into();
         self
     }
+    #[inline]
     pub fn advanced_blend_non_premultiplied_dst_color(
         mut self,
         advanced_blend_non_premultiplied_dst_color: bool,
@@ -23079,6 +25891,7 @@ impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
             advanced_blend_non_premultiplied_dst_color.into();
         self
     }
+    #[inline]
     pub fn advanced_blend_correlated_overlap(
         mut self,
         advanced_blend_correlated_overlap: bool,
@@ -23086,6 +25899,7 @@ impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
         self.inner.advanced_blend_correlated_overlap = advanced_blend_correlated_overlap.into();
         self
     }
+    #[inline]
     pub fn advanced_blend_all_operations(mut self, advanced_blend_all_operations: bool) -> Self {
         self.inner.advanced_blend_all_operations = advanced_blend_all_operations.into();
         self
@@ -23098,8 +25912,9 @@ impl<'a> PhysicalDeviceBlendOperationAdvancedPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html>"]
 pub struct PipelineColorBlendAdvancedStateCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -23108,9 +25923,10 @@ pub struct PipelineColorBlendAdvancedStateCreateInfoEXT {
     pub blend_overlap: BlendOverlapEXT,
 }
 impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT {
-    fn default() -> PipelineColorBlendAdvancedStateCreateInfoEXT {
-        PipelineColorBlendAdvancedStateCreateInfoEXT {
-            s_type: StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_premultiplied: Bool32::default(),
             dst_premultiplied: Bool32::default(),
@@ -23118,10 +25934,14 @@ impl ::std::default::Default for PipelineColorBlendAdvancedStateCreateInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineColorBlendAdvancedStateCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
+}
 impl PipelineColorBlendAdvancedStateCreateInfoEXT {
     pub fn builder<'a>() -> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
         PipelineColorBlendAdvancedStateCreateInfoEXTBuilder {
-            inner: PipelineColorBlendAdvancedStateCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23151,14 +25971,17 @@ impl<'a> ::std::ops::DerefMut for PipelineColorBlendAdvancedStateCreateInfoEXTBu
     }
 }
 impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self {
         self.inner.src_premultiplied = src_premultiplied.into();
         self
     }
+    #[inline]
     pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self {
         self.inner.dst_premultiplied = dst_premultiplied.into();
         self
     }
+    #[inline]
     pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self {
         self.inner.blend_overlap = blend_overlap;
         self
@@ -23171,60 +25994,65 @@ impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeaturesEXT.html>"]
-pub struct PhysicalDeviceInlineUniformBlockFeaturesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockFeatures.html>"]
+pub struct PhysicalDeviceInlineUniformBlockFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub inline_uniform_block: Bool32,
     pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeaturesEXT {
-    fn default() -> PhysicalDeviceInlineUniformBlockFeaturesEXT {
-        PhysicalDeviceInlineUniformBlockFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT,
+impl ::std::default::Default for PhysicalDeviceInlineUniformBlockFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             inline_uniform_block: Bool32::default(),
             descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceInlineUniformBlockFeaturesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
-        PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder {
-            inner: PhysicalDeviceInlineUniformBlockFeaturesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceInlineUniformBlockFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
+}
+impl PhysicalDeviceInlineUniformBlockFeatures {
+    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
+        PhysicalDeviceInlineUniformBlockFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
-    inner: PhysicalDeviceInlineUniformBlockFeaturesEXT,
+pub struct PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
+    inner: PhysicalDeviceInlineUniformBlockFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'_>
-{
-}
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesEXT {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'_> {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
-    type Target = PhysicalDeviceInlineUniformBlockFeaturesEXT;
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceInlineUniformBlockFeatures {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceInlineUniformBlockFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
+    type Target = PhysicalDeviceInlineUniformBlockFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceInlineUniformBlockFeaturesBuilder<'a> {
+    #[inline]
     pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self {
         self.inner.inline_uniform_block = inline_uniform_block.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_inline_uniform_block_update_after_bind(
         mut self,
         descriptor_binding_inline_uniform_block_update_after_bind: bool,
@@ -23237,14 +26065,15 @@ impl<'a> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeaturesEXT {
+    pub fn build(self) -> PhysicalDeviceInlineUniformBlockFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInlineUniformBlockPropertiesEXT.html>"]
-pub struct PhysicalDeviceInlineUniformBlockPropertiesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInlineUniformBlockProperties.html>"]
+pub struct PhysicalDeviceInlineUniformBlockProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_inline_uniform_block_size: u32,
@@ -23253,10 +26082,11 @@ pub struct PhysicalDeviceInlineUniformBlockPropertiesEXT {
     pub max_descriptor_set_inline_uniform_blocks: u32,
     pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
 }
-impl ::std::default::Default for PhysicalDeviceInlineUniformBlockPropertiesEXT {
-    fn default() -> PhysicalDeviceInlineUniformBlockPropertiesEXT {
-        PhysicalDeviceInlineUniformBlockPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT,
+impl ::std::default::Default for PhysicalDeviceInlineUniformBlockProperties {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_inline_uniform_block_size: u32::default(),
             max_per_stage_descriptor_inline_uniform_blocks: u32::default(),
@@ -23266,40 +26096,46 @@ impl ::std::default::Default for PhysicalDeviceInlineUniformBlockPropertiesEXT {
         }
     }
 }
-impl PhysicalDeviceInlineUniformBlockPropertiesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
-        PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder {
-            inner: PhysicalDeviceInlineUniformBlockPropertiesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceInlineUniformBlockProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
+}
+impl PhysicalDeviceInlineUniformBlockProperties {
+    pub fn builder<'a>() -> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
+        PhysicalDeviceInlineUniformBlockPropertiesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
-    inner: PhysicalDeviceInlineUniformBlockPropertiesEXT,
+pub struct PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
+    inner: PhysicalDeviceInlineUniformBlockProperties,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceProperties2
-    for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'_>
+    for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'_>
 {
 }
-unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockPropertiesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
-    type Target = PhysicalDeviceInlineUniformBlockPropertiesEXT;
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceInlineUniformBlockProperties {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
+    type Target = PhysicalDeviceInlineUniformBlockProperties;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceInlineUniformBlockPropertiesBuilder<'a> {
+    #[inline]
     pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self {
         self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_inline_uniform_blocks(
         mut self,
         max_per_stage_descriptor_inline_uniform_blocks: u32,
@@ -23308,6 +26144,7 @@ impl<'a> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
             max_per_stage_descriptor_inline_uniform_blocks;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
         mut self,
         max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
@@ -23317,6 +26154,7 @@ impl<'a> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_inline_uniform_blocks(
         mut self,
         max_descriptor_set_inline_uniform_blocks: u32,
@@ -23325,6 +26163,7 @@ impl<'a> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
             max_descriptor_set_inline_uniform_blocks;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
         mut self,
         max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
@@ -23337,115 +26176,128 @@ impl<'a> PhysicalDeviceInlineUniformBlockPropertiesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceInlineUniformBlockPropertiesEXT {
+    pub fn build(self) -> PhysicalDeviceInlineUniformBlockProperties {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSetInlineUniformBlockEXT.html>"]
-pub struct WriteDescriptorSetInlineUniformBlockEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetInlineUniformBlock.html>"]
+pub struct WriteDescriptorSetInlineUniformBlock {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub data_size: u32,
     pub p_data: *const c_void,
 }
-impl ::std::default::Default for WriteDescriptorSetInlineUniformBlockEXT {
-    fn default() -> WriteDescriptorSetInlineUniformBlockEXT {
-        WriteDescriptorSetInlineUniformBlockEXT {
-            s_type: StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT,
+impl ::std::default::Default for WriteDescriptorSetInlineUniformBlock {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             data_size: u32::default(),
             p_data: ::std::ptr::null(),
         }
     }
 }
-impl WriteDescriptorSetInlineUniformBlockEXT {
-    pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
-        WriteDescriptorSetInlineUniformBlockEXTBuilder {
-            inner: WriteDescriptorSetInlineUniformBlockEXT::default(),
+unsafe impl TaggedStructure for WriteDescriptorSetInlineUniformBlock {
+    const STRUCTURE_TYPE: StructureType = StructureType::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
+}
+impl WriteDescriptorSetInlineUniformBlock {
+    pub fn builder<'a>() -> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
+        WriteDescriptorSetInlineUniformBlockBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
-    inner: WriteDescriptorSetInlineUniformBlockEXT,
+pub struct WriteDescriptorSetInlineUniformBlockBuilder<'a> {
+    inner: WriteDescriptorSetInlineUniformBlock,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXTBuilder<'_> {}
-unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockEXT {}
-impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
-    type Target = WriteDescriptorSetInlineUniformBlockEXT;
+unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlockBuilder<'_> {}
+unsafe impl ExtendsWriteDescriptorSet for WriteDescriptorSetInlineUniformBlock {}
+impl<'a> ::std::ops::Deref for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
+    type Target = WriteDescriptorSetInlineUniformBlock;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for WriteDescriptorSetInlineUniformBlockBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
+impl<'a> WriteDescriptorSetInlineUniformBlockBuilder<'a> {
+    #[inline]
     pub fn data(mut self, data: &'a [u8]) -> Self {
         self.inner.data_size = data.len() as _;
-        self.inner.p_data = data.as_ptr() as *const c_void;
+        self.inner.p_data = data.as_ptr().cast();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> WriteDescriptorSetInlineUniformBlockEXT {
+    pub fn build(self) -> WriteDescriptorSetInlineUniformBlock {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorPoolInlineUniformBlockCreateInfoEXT.html>"]
-pub struct DescriptorPoolInlineUniformBlockCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorPoolInlineUniformBlockCreateInfo.html>"]
+pub struct DescriptorPoolInlineUniformBlockCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub max_inline_uniform_block_bindings: u32,
 }
-impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfoEXT {
-    fn default() -> DescriptorPoolInlineUniformBlockCreateInfoEXT {
-        DescriptorPoolInlineUniformBlockCreateInfoEXT {
-            s_type: StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT,
+impl ::std::default::Default for DescriptorPoolInlineUniformBlockCreateInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             max_inline_uniform_block_bindings: u32::default(),
         }
     }
 }
-impl DescriptorPoolInlineUniformBlockCreateInfoEXT {
-    pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
-        DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder {
-            inner: DescriptorPoolInlineUniformBlockCreateInfoEXT::default(),
+unsafe impl TaggedStructure for DescriptorPoolInlineUniformBlockCreateInfo {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
+}
+impl DescriptorPoolInlineUniformBlockCreateInfo {
+    pub fn builder<'a>() -> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
+        DescriptorPoolInlineUniformBlockCreateInfoBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
-    inner: DescriptorPoolInlineUniformBlockCreateInfoEXT,
+pub struct DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
+    inner: DescriptorPoolInlineUniformBlockCreateInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsDescriptorPoolCreateInfo
-    for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'_>
+    for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'_>
 {
 }
-unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfoEXT {}
-impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
-    type Target = DescriptorPoolInlineUniformBlockCreateInfoEXT;
+unsafe impl ExtendsDescriptorPoolCreateInfo for DescriptorPoolInlineUniformBlockCreateInfo {}
+impl<'a> ::std::ops::Deref for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
+    type Target = DescriptorPoolInlineUniformBlockCreateInfo;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
+impl<'a> DescriptorPoolInlineUniformBlockCreateInfoBuilder<'a> {
+    #[inline]
     pub fn max_inline_uniform_block_bindings(
         mut self,
         max_inline_uniform_block_bindings: u32,
@@ -23456,13 +26308,14 @@ impl<'a> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfoEXT {
+    pub fn build(self) -> DescriptorPoolInlineUniformBlockCreateInfo {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html>"]
 pub struct PipelineCoverageModulationStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -23473,9 +26326,10 @@ pub struct PipelineCoverageModulationStateCreateInfoNV {
     pub p_coverage_modulation_table: *const f32,
 }
 impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV {
-    fn default() -> PipelineCoverageModulationStateCreateInfoNV {
-        PipelineCoverageModulationStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineCoverageModulationStateCreateFlagsNV::default(),
             coverage_modulation_mode: CoverageModulationModeNV::default(),
@@ -23485,10 +26339,14 @@ impl ::std::default::Default for PipelineCoverageModulationStateCreateInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineCoverageModulationStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV;
+}
 impl PipelineCoverageModulationStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
         PipelineCoverageModulationStateCreateInfoNVBuilder {
-            inner: PipelineCoverageModulationStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23518,10 +26376,12 @@ impl<'a> ::std::ops::DerefMut for PipelineCoverageModulationStateCreateInfoNVBui
     }
 }
 impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineCoverageModulationStateCreateFlagsNV) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn coverage_modulation_mode(
         mut self,
         coverage_modulation_mode: CoverageModulationModeNV,
@@ -23529,6 +26389,7 @@ impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
         self.inner.coverage_modulation_mode = coverage_modulation_mode;
         self
     }
+    #[inline]
     pub fn coverage_modulation_table_enable(
         mut self,
         coverage_modulation_table_enable: bool,
@@ -23536,6 +26397,7 @@ impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
         self.inner.coverage_modulation_table_enable = coverage_modulation_table_enable.into();
         self
     }
+    #[inline]
     pub fn coverage_modulation_table(mut self, coverage_modulation_table: &'a [f32]) -> Self {
         self.inner.coverage_modulation_table_count = coverage_modulation_table.len() as _;
         self.inner.p_coverage_modulation_table = coverage_modulation_table.as_ptr();
@@ -23549,8 +26411,9 @@ impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageFormatListCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatListCreateInfo.html>"]
 pub struct ImageFormatListCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -23558,19 +26421,23 @@ pub struct ImageFormatListCreateInfo {
     pub p_view_formats: *const Format,
 }
 impl ::std::default::Default for ImageFormatListCreateInfo {
-    fn default() -> ImageFormatListCreateInfo {
-        ImageFormatListCreateInfo {
-            s_type: StructureType::IMAGE_FORMAT_LIST_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             view_format_count: u32::default(),
             p_view_formats: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageFormatListCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_LIST_CREATE_INFO;
+}
 impl ImageFormatListCreateInfo {
     pub fn builder<'a>() -> ImageFormatListCreateInfoBuilder<'a> {
         ImageFormatListCreateInfoBuilder {
-            inner: ImageFormatListCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23598,6 +26465,7 @@ impl<'a> ::std::ops::DerefMut for ImageFormatListCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ImageFormatListCreateInfoBuilder<'a> {
+    #[inline]
     pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
         self.inner.view_format_count = view_formats.len() as _;
         self.inner.p_view_formats = view_formats.as_ptr();
@@ -23611,8 +26479,9 @@ impl<'a> ImageFormatListCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheCreateInfoEXT.html>"]
 pub struct ValidationCacheCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -23621,9 +26490,10 @@ pub struct ValidationCacheCreateInfoEXT {
     pub p_initial_data: *const c_void,
 }
 impl ::std::default::Default for ValidationCacheCreateInfoEXT {
-    fn default() -> ValidationCacheCreateInfoEXT {
-        ValidationCacheCreateInfoEXT {
-            s_type: StructureType::VALIDATION_CACHE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: ValidationCacheCreateFlagsEXT::default(),
             initial_data_size: usize::default(),
@@ -23631,10 +26501,13 @@ impl ::std::default::Default for ValidationCacheCreateInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for ValidationCacheCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VALIDATION_CACHE_CREATE_INFO_EXT;
+}
 impl ValidationCacheCreateInfoEXT {
     pub fn builder<'a>() -> ValidationCacheCreateInfoEXTBuilder<'a> {
         ValidationCacheCreateInfoEXTBuilder {
-            inner: ValidationCacheCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23656,13 +26529,15 @@ impl<'a> ::std::ops::DerefMut for ValidationCacheCreateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: ValidationCacheCreateFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn initial_data(mut self, initial_data: &'a [u8]) -> Self {
-        self.inner.initial_data_size = initial_data.len() as _;
-        self.inner.p_initial_data = initial_data.as_ptr() as *const c_void;
+        self.inner.initial_data_size = initial_data.len();
+        self.inner.p_initial_data = initial_data.as_ptr().cast();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -23673,26 +26548,32 @@ impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html>"]
 pub struct ShaderModuleValidationCacheCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub validation_cache: ValidationCacheEXT,
 }
 impl ::std::default::Default for ShaderModuleValidationCacheCreateInfoEXT {
-    fn default() -> ShaderModuleValidationCacheCreateInfoEXT {
-        ShaderModuleValidationCacheCreateInfoEXT {
-            s_type: StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             validation_cache: ValidationCacheEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ShaderModuleValidationCacheCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT;
+}
 impl ShaderModuleValidationCacheCreateInfoEXT {
     pub fn builder<'a>() -> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
         ShaderModuleValidationCacheCreateInfoEXTBuilder {
-            inner: ShaderModuleValidationCacheCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23704,6 +26585,11 @@ pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
 }
 unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_> {}
 unsafe impl ExtendsShaderModuleCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {}
+unsafe impl ExtendsPipelineShaderStageCreateInfo
+    for ShaderModuleValidationCacheCreateInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPipelineShaderStageCreateInfo for ShaderModuleValidationCacheCreateInfoEXT {}
 impl<'a> ::std::ops::Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
     type Target = ShaderModuleValidationCacheCreateInfoEXT;
     fn deref(&self) -> &Self::Target {
@@ -23716,6 +26602,7 @@ impl<'a> ::std::ops::DerefMut for ShaderModuleValidationCacheCreateInfoEXTBuilde
     }
 }
 impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn validation_cache(mut self, validation_cache: ValidationCacheEXT) -> Self {
         self.inner.validation_cache = validation_cache;
         self
@@ -23728,8 +26615,9 @@ impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMaintenance3Properties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance3Properties.html>"]
 pub struct PhysicalDeviceMaintenance3Properties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -23737,19 +26625,23 @@ pub struct PhysicalDeviceMaintenance3Properties {
     pub max_memory_allocation_size: DeviceSize,
 }
 impl ::std::default::Default for PhysicalDeviceMaintenance3Properties {
-    fn default() -> PhysicalDeviceMaintenance3Properties {
-        PhysicalDeviceMaintenance3Properties {
-            s_type: StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_per_set_descriptors: u32::default(),
             max_memory_allocation_size: DeviceSize::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMaintenance3Properties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+}
 impl PhysicalDeviceMaintenance3Properties {
     pub fn builder<'a>() -> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
         PhysicalDeviceMaintenance3PropertiesBuilder {
-            inner: PhysicalDeviceMaintenance3Properties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23773,10 +26665,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance3PropertiesBuilder<'a
     }
 }
 impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
+    #[inline]
     pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
         self.inner.max_per_set_descriptors = max_per_set_descriptors;
         self
     }
+    #[inline]
     pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self {
         self.inner.max_memory_allocation_size = max_memory_allocation_size;
         self
@@ -23789,26 +26683,155 @@ impl<'a> PhysicalDeviceMaintenance3PropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutSupport.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4Features.html>"]
+pub struct PhysicalDeviceMaintenance4Features {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub maintenance4: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceMaintenance4Features {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            maintenance4: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMaintenance4Features {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
+}
+impl PhysicalDeviceMaintenance4Features {
+    pub fn builder<'a>() -> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
+        PhysicalDeviceMaintenance4FeaturesBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
+    inner: PhysicalDeviceMaintenance4Features,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMaintenance4Features {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4FeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMaintenance4Features {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
+    type Target = PhysicalDeviceMaintenance4Features;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMaintenance4FeaturesBuilder<'a> {
+    #[inline]
+    pub fn maintenance4(mut self, maintenance4: bool) -> Self {
+        self.inner.maintenance4 = maintenance4.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMaintenance4Features {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMaintenance4Properties.html>"]
+pub struct PhysicalDeviceMaintenance4Properties {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub max_buffer_size: DeviceSize,
+}
+impl ::std::default::Default for PhysicalDeviceMaintenance4Properties {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            max_buffer_size: DeviceSize::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMaintenance4Properties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
+}
+impl PhysicalDeviceMaintenance4Properties {
+    pub fn builder<'a>() -> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
+        PhysicalDeviceMaintenance4PropertiesBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
+    inner: PhysicalDeviceMaintenance4Properties,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4PropertiesBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMaintenance4Properties {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
+    type Target = PhysicalDeviceMaintenance4Properties;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMaintenance4PropertiesBuilder<'a> {
+    #[inline]
+    pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self {
+        self.inner.max_buffer_size = max_buffer_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMaintenance4Properties {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutSupport.html>"]
 pub struct DescriptorSetLayoutSupport {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub supported: Bool32,
 }
 impl ::std::default::Default for DescriptorSetLayoutSupport {
-    fn default() -> DescriptorSetLayoutSupport {
-        DescriptorSetLayoutSupport {
-            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             supported: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DescriptorSetLayoutSupport {
+    const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_LAYOUT_SUPPORT;
+}
 impl DescriptorSetLayoutSupport {
     pub fn builder<'a>() -> DescriptorSetLayoutSupportBuilder<'a> {
         DescriptorSetLayoutSupportBuilder {
-            inner: DescriptorSetLayoutSupport::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23831,6 +26854,7 @@ impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutSupportBuilder<'a> {
     }
 }
 impl<'a> DescriptorSetLayoutSupportBuilder<'a> {
+    #[inline]
     pub fn supported(mut self, supported: bool) -> Self {
         self.inner.supported = supported.into();
         self
@@ -23842,10 +26866,10 @@ impl<'a> DescriptorSetLayoutSupportBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsDescriptorSetLayoutSupport>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -23857,26 +26881,32 @@ impl<'a> DescriptorSetLayoutSupportBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html>"]
 pub struct PhysicalDeviceShaderDrawParametersFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shader_draw_parameters: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderDrawParametersFeatures {
-    fn default() -> PhysicalDeviceShaderDrawParametersFeatures {
-        PhysicalDeviceShaderDrawParametersFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_draw_parameters: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderDrawParametersFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
+}
 impl PhysicalDeviceShaderDrawParametersFeatures {
     pub fn builder<'a>() -> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
         PhysicalDeviceShaderDrawParametersFeaturesBuilder {
-            inner: PhysicalDeviceShaderDrawParametersFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23905,6 +26935,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDrawParametersFeaturesBuil
     }
 }
 impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
+    #[inline]
     pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
         self.inner.shader_draw_parameters = shader_draw_parameters.into();
         self
@@ -23917,8 +26948,9 @@ impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html>"]
 pub struct PhysicalDeviceShaderFloat16Int8Features {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -23926,19 +26958,24 @@ pub struct PhysicalDeviceShaderFloat16Int8Features {
     pub shader_int8: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderFloat16Int8Features {
-    fn default() -> PhysicalDeviceShaderFloat16Int8Features {
-        PhysicalDeviceShaderFloat16Int8Features {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_float16: Bool32::default(),
             shader_int8: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderFloat16Int8Features {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
+}
 impl PhysicalDeviceShaderFloat16Int8Features {
     pub fn builder<'a>() -> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
         PhysicalDeviceShaderFloat16Int8FeaturesBuilder {
-            inner: PhysicalDeviceShaderFloat16Int8Features::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -23964,10 +27001,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderFloat16Int8FeaturesBuilder
     }
 }
 impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
+    #[inline]
     pub fn shader_float16(mut self, shader_float16: bool) -> Self {
         self.inner.shader_float16 = shader_float16.into();
         self
     }
+    #[inline]
     pub fn shader_int8(mut self, shader_int8: bool) -> Self {
         self.inner.shader_int8 = shader_int8.into();
         self
@@ -23980,8 +27019,9 @@ impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFloatControlsProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFloatControlsProperties.html>"]
 pub struct PhysicalDeviceFloatControlsProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -24004,9 +27044,10 @@ pub struct PhysicalDeviceFloatControlsProperties {
     pub shader_rounding_mode_rtz_float64: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceFloatControlsProperties {
-    fn default() -> PhysicalDeviceFloatControlsProperties {
-        PhysicalDeviceFloatControlsProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             denorm_behavior_independence: ShaderFloatControlsIndependence::default(),
             rounding_mode_independence: ShaderFloatControlsIndependence::default(),
@@ -24028,10 +27069,13 @@ impl ::std::default::Default for PhysicalDeviceFloatControlsProperties {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFloatControlsProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
+}
 impl PhysicalDeviceFloatControlsProperties {
     pub fn builder<'a>() -> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         PhysicalDeviceFloatControlsPropertiesBuilder {
-            inner: PhysicalDeviceFloatControlsProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24055,6 +27099,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFloatControlsPropertiesBuilder<'
     }
 }
 impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
+    #[inline]
     pub fn denorm_behavior_independence(
         mut self,
         denorm_behavior_independence: ShaderFloatControlsIndependence,
@@ -24062,6 +27107,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.denorm_behavior_independence = denorm_behavior_independence;
         self
     }
+    #[inline]
     pub fn rounding_mode_independence(
         mut self,
         rounding_mode_independence: ShaderFloatControlsIndependence,
@@ -24069,6 +27115,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.rounding_mode_independence = rounding_mode_independence;
         self
     }
+    #[inline]
     pub fn shader_signed_zero_inf_nan_preserve_float16(
         mut self,
         shader_signed_zero_inf_nan_preserve_float16: bool,
@@ -24077,6 +27124,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
             shader_signed_zero_inf_nan_preserve_float16.into();
         self
     }
+    #[inline]
     pub fn shader_signed_zero_inf_nan_preserve_float32(
         mut self,
         shader_signed_zero_inf_nan_preserve_float32: bool,
@@ -24085,6 +27133,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
             shader_signed_zero_inf_nan_preserve_float32.into();
         self
     }
+    #[inline]
     pub fn shader_signed_zero_inf_nan_preserve_float64(
         mut self,
         shader_signed_zero_inf_nan_preserve_float64: bool,
@@ -24093,18 +27142,22 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
             shader_signed_zero_inf_nan_preserve_float64.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self {
         self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self {
         self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self {
         self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_flush_to_zero_float16(
         mut self,
         shader_denorm_flush_to_zero_float16: bool,
@@ -24112,6 +27165,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_flush_to_zero_float32(
         mut self,
         shader_denorm_flush_to_zero_float32: bool,
@@ -24119,6 +27173,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_flush_to_zero_float64(
         mut self,
         shader_denorm_flush_to_zero_float64: bool,
@@ -24126,6 +27181,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rte_float16(
         mut self,
         shader_rounding_mode_rte_float16: bool,
@@ -24133,6 +27189,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rte_float32(
         mut self,
         shader_rounding_mode_rte_float32: bool,
@@ -24140,6 +27197,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rte_float64(
         mut self,
         shader_rounding_mode_rte_float64: bool,
@@ -24147,6 +27205,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rtz_float16(
         mut self,
         shader_rounding_mode_rtz_float16: bool,
@@ -24154,6 +27213,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rtz_float32(
         mut self,
         shader_rounding_mode_rtz_float32: bool,
@@ -24161,6 +27221,7 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rtz_float64(
         mut self,
         shader_rounding_mode_rtz_float64: bool,
@@ -24176,26 +27237,31 @@ impl<'a> PhysicalDeviceFloatControlsPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceHostQueryResetFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceHostQueryResetFeatures.html>"]
 pub struct PhysicalDeviceHostQueryResetFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub host_query_reset: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceHostQueryResetFeatures {
-    fn default() -> PhysicalDeviceHostQueryResetFeatures {
-        PhysicalDeviceHostQueryResetFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             host_query_reset: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceHostQueryResetFeatures {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
+}
 impl PhysicalDeviceHostQueryResetFeatures {
     pub fn builder<'a>() -> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
         PhysicalDeviceHostQueryResetFeaturesBuilder {
-            inner: PhysicalDeviceHostQueryResetFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24221,6 +27287,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceHostQueryResetFeaturesBuilder<'a
     }
 }
 impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
+    #[inline]
     pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
         self.inner.host_query_reset = host_query_reset.into();
         self
@@ -24233,8 +27300,9 @@ impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkNativeBufferUsage2ANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkNativeBufferUsage2ANDROID.html>"]
 pub struct NativeBufferUsage2ANDROID {
     pub consumer: u64,
     pub producer: u64,
@@ -24242,7 +27310,7 @@ pub struct NativeBufferUsage2ANDROID {
 impl NativeBufferUsage2ANDROID {
     pub fn builder<'a>() -> NativeBufferUsage2ANDROIDBuilder<'a> {
         NativeBufferUsage2ANDROIDBuilder {
-            inner: NativeBufferUsage2ANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24264,10 +27332,12 @@ impl<'a> ::std::ops::DerefMut for NativeBufferUsage2ANDROIDBuilder<'a> {
     }
 }
 impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> {
+    #[inline]
     pub fn consumer(mut self, consumer: u64) -> Self {
         self.inner.consumer = consumer;
         self
     }
+    #[inline]
     pub fn producer(mut self, producer: u64) -> Self {
         self.inner.producer = producer;
         self
@@ -24280,8 +27350,9 @@ impl<'a> NativeBufferUsage2ANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkNativeBufferANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkNativeBufferANDROID.html>"]
 pub struct NativeBufferANDROID {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -24292,9 +27363,10 @@ pub struct NativeBufferANDROID {
     pub usage2: NativeBufferUsage2ANDROID,
 }
 impl ::std::default::Default for NativeBufferANDROID {
-    fn default() -> NativeBufferANDROID {
-        NativeBufferANDROID {
-            s_type: StructureType::NATIVE_BUFFER_ANDROID,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle: ::std::ptr::null(),
             stride: c_int::default(),
@@ -24304,10 +27376,13 @@ impl ::std::default::Default for NativeBufferANDROID {
         }
     }
 }
+unsafe impl TaggedStructure for NativeBufferANDROID {
+    const STRUCTURE_TYPE: StructureType = StructureType::NATIVE_BUFFER_ANDROID;
+}
 impl NativeBufferANDROID {
     pub fn builder<'a>() -> NativeBufferANDROIDBuilder<'a> {
         NativeBufferANDROIDBuilder {
-            inner: NativeBufferANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24329,22 +27404,27 @@ impl<'a> ::std::ops::DerefMut for NativeBufferANDROIDBuilder<'a> {
     }
 }
 impl<'a> NativeBufferANDROIDBuilder<'a> {
+    #[inline]
     pub fn handle(mut self, handle: *const c_void) -> Self {
         self.inner.handle = handle;
         self
     }
+    #[inline]
     pub fn stride(mut self, stride: c_int) -> Self {
         self.inner.stride = stride;
         self
     }
+    #[inline]
     pub fn format(mut self, format: c_int) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn usage(mut self, usage: c_int) -> Self {
         self.inner.usage = usage;
         self
     }
+    #[inline]
     pub fn usage2(mut self, usage2: NativeBufferUsage2ANDROID) -> Self {
         self.inner.usage2 = usage2;
         self
@@ -24357,26 +27437,31 @@ impl<'a> NativeBufferANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSwapchainImageCreateInfoANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainImageCreateInfoANDROID.html>"]
 pub struct SwapchainImageCreateInfoANDROID {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub usage: SwapchainImageUsageFlagsANDROID,
 }
 impl ::std::default::Default for SwapchainImageCreateInfoANDROID {
-    fn default() -> SwapchainImageCreateInfoANDROID {
-        SwapchainImageCreateInfoANDROID {
-            s_type: StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             usage: SwapchainImageUsageFlagsANDROID::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SwapchainImageCreateInfoANDROID {
+    const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID;
+}
 impl SwapchainImageCreateInfoANDROID {
     pub fn builder<'a>() -> SwapchainImageCreateInfoANDROIDBuilder<'a> {
         SwapchainImageCreateInfoANDROIDBuilder {
-            inner: SwapchainImageCreateInfoANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24398,6 +27483,7 @@ impl<'a> ::std::ops::DerefMut for SwapchainImageCreateInfoANDROIDBuilder<'a> {
     }
 }
 impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> {
+    #[inline]
     pub fn usage(mut self, usage: SwapchainImageUsageFlagsANDROID) -> Self {
         self.inner.usage = usage;
         self
@@ -24410,26 +27496,32 @@ impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePresentationPropertiesANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentationPropertiesANDROID.html>"]
 pub struct PhysicalDevicePresentationPropertiesANDROID {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub shared_image: Bool32,
 }
 impl ::std::default::Default for PhysicalDevicePresentationPropertiesANDROID {
-    fn default() -> PhysicalDevicePresentationPropertiesANDROID {
-        PhysicalDevicePresentationPropertiesANDROID {
-            s_type: StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             shared_image: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePresentationPropertiesANDROID {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID;
+}
 impl PhysicalDevicePresentationPropertiesANDROID {
     pub fn builder<'a>() -> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
         PhysicalDevicePresentationPropertiesANDROIDBuilder {
-            inner: PhysicalDevicePresentationPropertiesANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24451,6 +27543,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentationPropertiesANDROIDBui
     }
 }
 impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
+    #[inline]
     pub fn shared_image(mut self, shared_image: bool) -> Self {
         self.inner.shared_image = shared_image.into();
         self
@@ -24463,8 +27556,9 @@ impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderResourceUsageAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderResourceUsageAMD.html>"]
 pub struct ShaderResourceUsageAMD {
     pub num_used_vgprs: u32,
     pub num_used_sgprs: u32,
@@ -24475,7 +27569,7 @@ pub struct ShaderResourceUsageAMD {
 impl ShaderResourceUsageAMD {
     pub fn builder<'a>() -> ShaderResourceUsageAMDBuilder<'a> {
         ShaderResourceUsageAMDBuilder {
-            inner: ShaderResourceUsageAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24497,22 +27591,27 @@ impl<'a> ::std::ops::DerefMut for ShaderResourceUsageAMDBuilder<'a> {
     }
 }
 impl<'a> ShaderResourceUsageAMDBuilder<'a> {
+    #[inline]
     pub fn num_used_vgprs(mut self, num_used_vgprs: u32) -> Self {
         self.inner.num_used_vgprs = num_used_vgprs;
         self
     }
+    #[inline]
     pub fn num_used_sgprs(mut self, num_used_sgprs: u32) -> Self {
         self.inner.num_used_sgprs = num_used_sgprs;
         self
     }
+    #[inline]
     pub fn lds_size_per_local_work_group(mut self, lds_size_per_local_work_group: u32) -> Self {
         self.inner.lds_size_per_local_work_group = lds_size_per_local_work_group;
         self
     }
+    #[inline]
     pub fn lds_usage_size_in_bytes(mut self, lds_usage_size_in_bytes: usize) -> Self {
         self.inner.lds_usage_size_in_bytes = lds_usage_size_in_bytes;
         self
     }
+    #[inline]
     pub fn scratch_mem_usage_in_bytes(mut self, scratch_mem_usage_in_bytes: usize) -> Self {
         self.inner.scratch_mem_usage_in_bytes = scratch_mem_usage_in_bytes;
         self
@@ -24525,8 +27624,9 @@ impl<'a> ShaderResourceUsageAMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderStatisticsInfoAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderStatisticsInfoAMD.html>"]
 pub struct ShaderStatisticsInfoAMD {
     pub shader_stage_mask: ShaderStageFlags,
     pub resource_usage: ShaderResourceUsageAMD,
@@ -24537,8 +27637,9 @@ pub struct ShaderStatisticsInfoAMD {
     pub compute_work_group_size: [u32; 3],
 }
 impl ::std::default::Default for ShaderStatisticsInfoAMD {
-    fn default() -> ShaderStatisticsInfoAMD {
-        ShaderStatisticsInfoAMD {
+    #[inline]
+    fn default() -> Self {
+        Self {
             shader_stage_mask: ShaderStageFlags::default(),
             resource_usage: ShaderResourceUsageAMD::default(),
             num_physical_vgprs: u32::default(),
@@ -24552,7 +27653,7 @@ impl ::std::default::Default for ShaderStatisticsInfoAMD {
 impl ShaderStatisticsInfoAMD {
     pub fn builder<'a>() -> ShaderStatisticsInfoAMDBuilder<'a> {
         ShaderStatisticsInfoAMDBuilder {
-            inner: ShaderStatisticsInfoAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24574,30 +27675,37 @@ impl<'a> ::std::ops::DerefMut for ShaderStatisticsInfoAMDBuilder<'a> {
     }
 }
 impl<'a> ShaderStatisticsInfoAMDBuilder<'a> {
+    #[inline]
     pub fn shader_stage_mask(mut self, shader_stage_mask: ShaderStageFlags) -> Self {
         self.inner.shader_stage_mask = shader_stage_mask;
         self
     }
+    #[inline]
     pub fn resource_usage(mut self, resource_usage: ShaderResourceUsageAMD) -> Self {
         self.inner.resource_usage = resource_usage;
         self
     }
+    #[inline]
     pub fn num_physical_vgprs(mut self, num_physical_vgprs: u32) -> Self {
         self.inner.num_physical_vgprs = num_physical_vgprs;
         self
     }
+    #[inline]
     pub fn num_physical_sgprs(mut self, num_physical_sgprs: u32) -> Self {
         self.inner.num_physical_sgprs = num_physical_sgprs;
         self
     }
+    #[inline]
     pub fn num_available_vgprs(mut self, num_available_vgprs: u32) -> Self {
         self.inner.num_available_vgprs = num_available_vgprs;
         self
     }
+    #[inline]
     pub fn num_available_sgprs(mut self, num_available_sgprs: u32) -> Self {
         self.inner.num_available_sgprs = num_available_sgprs;
         self
     }
+    #[inline]
     pub fn compute_work_group_size(mut self, compute_work_group_size: [u32; 3]) -> Self {
         self.inner.compute_work_group_size = compute_work_group_size;
         self
@@ -24610,109 +27718,123 @@ impl<'a> ShaderStatisticsInfoAMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceQueueGlobalPriorityCreateInfoEXT.html>"]
-pub struct DeviceQueueGlobalPriorityCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceQueueGlobalPriorityCreateInfoKHR.html>"]
+pub struct DeviceQueueGlobalPriorityCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub global_priority: QueueGlobalPriorityEXT,
+    pub global_priority: QueueGlobalPriorityKHR,
 }
-impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoEXT {
-    fn default() -> DeviceQueueGlobalPriorityCreateInfoEXT {
-        DeviceQueueGlobalPriorityCreateInfoEXT {
-            s_type: StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT,
+impl ::std::default::Default for DeviceQueueGlobalPriorityCreateInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            global_priority: QueueGlobalPriorityEXT::default(),
+            global_priority: QueueGlobalPriorityKHR::default(),
         }
     }
 }
-impl DeviceQueueGlobalPriorityCreateInfoEXT {
-    pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
-        DeviceQueueGlobalPriorityCreateInfoEXTBuilder {
-            inner: DeviceQueueGlobalPriorityCreateInfoEXT::default(),
+unsafe impl TaggedStructure for DeviceQueueGlobalPriorityCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
+}
+impl DeviceQueueGlobalPriorityCreateInfoKHR {
+    pub fn builder<'a>() -> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
+        DeviceQueueGlobalPriorityCreateInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
-    inner: DeviceQueueGlobalPriorityCreateInfoEXT,
+pub struct DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
+    inner: DeviceQueueGlobalPriorityCreateInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'_> {}
-unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoEXT {}
-impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
-    type Target = DeviceQueueGlobalPriorityCreateInfoEXT;
+unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'_> {}
+unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueGlobalPriorityCreateInfoKHR {}
+impl<'a> ::std::ops::Deref for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
+    type Target = DeviceQueueGlobalPriorityCreateInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
-    pub fn global_priority(mut self, global_priority: QueueGlobalPriorityEXT) -> Self {
+impl<'a> DeviceQueueGlobalPriorityCreateInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn global_priority(mut self, global_priority: QueueGlobalPriorityKHR) -> Self {
         self.inner.global_priority = global_priority;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoEXT {
+    pub fn build(self) -> DeviceQueueGlobalPriorityCreateInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT.html>"]
-pub struct PhysicalDeviceGlobalPriorityQueryFeaturesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR.html>"]
+pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub global_priority_query: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesEXT {
-    fn default() -> PhysicalDeviceGlobalPriorityQueryFeaturesEXT {
-        PhysicalDeviceGlobalPriorityQueryFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT,
+impl ::std::default::Default for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             global_priority_query: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceGlobalPriorityQueryFeaturesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> {
-        PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder {
-            inner: PhysicalDeviceGlobalPriorityQueryFeaturesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
+}
+impl PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
+    pub fn builder<'a>() -> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
+        PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> {
-    inner: PhysicalDeviceGlobalPriorityQueryFeaturesEXT,
+pub struct PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
+    inner: PhysicalDeviceGlobalPriorityQueryFeaturesKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'_>
+    for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_>
 {
 }
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesEXT {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'_> {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> {
-    type Target = PhysicalDeviceGlobalPriorityQueryFeaturesEXT;
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGlobalPriorityQueryFeaturesKHR {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
+    type Target = PhysicalDeviceGlobalPriorityQueryFeaturesKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn global_priority_query(mut self, global_priority_query: bool) -> Self {
         self.inner.global_priority_query = global_priority_query.into();
         self
@@ -24720,63 +27842,71 @@ impl<'a> PhysicalDeviceGlobalPriorityQueryFeaturesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesEXT {
+    pub fn build(self) -> PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyGlobalPriorityPropertiesEXT.html>"]
-pub struct QueueFamilyGlobalPriorityPropertiesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyGlobalPriorityPropertiesKHR.html>"]
+pub struct QueueFamilyGlobalPriorityPropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub priority_count: u32,
-    pub priorities: [QueueGlobalPriorityEXT; MAX_GLOBAL_PRIORITY_SIZE_EXT],
+    pub priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR],
 }
-impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesEXT {
-    fn default() -> QueueFamilyGlobalPriorityPropertiesEXT {
-        QueueFamilyGlobalPriorityPropertiesEXT {
-            s_type: StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT,
+impl ::std::default::Default for QueueFamilyGlobalPriorityPropertiesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             priority_count: u32::default(),
             priorities: unsafe { ::std::mem::zeroed() },
         }
     }
 }
-impl QueueFamilyGlobalPriorityPropertiesEXT {
-    pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> {
-        QueueFamilyGlobalPriorityPropertiesEXTBuilder {
-            inner: QueueFamilyGlobalPriorityPropertiesEXT::default(),
+unsafe impl TaggedStructure for QueueFamilyGlobalPriorityPropertiesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
+}
+impl QueueFamilyGlobalPriorityPropertiesKHR {
+    pub fn builder<'a>() -> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
+        QueueFamilyGlobalPriorityPropertiesKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> {
-    inner: QueueFamilyGlobalPriorityPropertiesEXT,
+pub struct QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
+    inner: QueueFamilyGlobalPriorityPropertiesKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesEXTBuilder<'_> {}
-unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesEXT {}
-impl<'a> ::std::ops::Deref for QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> {
-    type Target = QueueFamilyGlobalPriorityPropertiesEXT;
+unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'_> {}
+unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyGlobalPriorityPropertiesKHR {}
+impl<'a> ::std::ops::Deref for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
+    type Target = QueueFamilyGlobalPriorityPropertiesKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> {
+impl<'a> QueueFamilyGlobalPriorityPropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn priority_count(mut self, priority_count: u32) -> Self {
         self.inner.priority_count = priority_count;
         self
     }
+    #[inline]
     pub fn priorities(
         mut self,
-        priorities: [QueueGlobalPriorityEXT; MAX_GLOBAL_PRIORITY_SIZE_EXT],
+        priorities: [QueueGlobalPriorityKHR; MAX_GLOBAL_PRIORITY_SIZE_KHR],
     ) -> Self {
         self.inner.priorities = priorities;
         self
@@ -24784,13 +27914,14 @@ impl<'a> QueueFamilyGlobalPriorityPropertiesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> QueueFamilyGlobalPriorityPropertiesEXT {
+    pub fn build(self) -> QueueFamilyGlobalPriorityPropertiesKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsObjectNameInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectNameInfoEXT.html>"]
 pub struct DebugUtilsObjectNameInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -24799,9 +27930,10 @@ pub struct DebugUtilsObjectNameInfoEXT {
     pub p_object_name: *const c_char,
 }
 impl ::std::default::Default for DebugUtilsObjectNameInfoEXT {
-    fn default() -> DebugUtilsObjectNameInfoEXT {
-        DebugUtilsObjectNameInfoEXT {
-            s_type: StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             object_type: ObjectType::default(),
             object_handle: u64::default(),
@@ -24809,10 +27941,13 @@ impl ::std::default::Default for DebugUtilsObjectNameInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DebugUtilsObjectNameInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+}
 impl DebugUtilsObjectNameInfoEXT {
     pub fn builder<'a>() -> DebugUtilsObjectNameInfoEXTBuilder<'a> {
         DebugUtilsObjectNameInfoEXTBuilder {
-            inner: DebugUtilsObjectNameInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24822,6 +27957,8 @@ pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> {
     inner: DebugUtilsObjectNameInfoEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+unsafe impl ExtendsPipelineShaderStageCreateInfo for DebugUtilsObjectNameInfoEXTBuilder<'_> {}
+unsafe impl ExtendsPipelineShaderStageCreateInfo for DebugUtilsObjectNameInfoEXT {}
 impl<'a> ::std::ops::Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> {
     type Target = DebugUtilsObjectNameInfoEXT;
     fn deref(&self) -> &Self::Target {
@@ -24834,14 +27971,17 @@ impl<'a> ::std::ops::DerefMut for DebugUtilsObjectNameInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> {
+    #[inline]
     pub fn object_type(mut self, object_type: ObjectType) -> Self {
         self.inner.object_type = object_type;
         self
     }
+    #[inline]
     pub fn object_handle(mut self, object_handle: u64) -> Self {
         self.inner.object_handle = object_handle;
         self
     }
+    #[inline]
     pub fn object_name(mut self, object_name: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_object_name = object_name.as_ptr();
         self
@@ -24854,8 +27994,9 @@ impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsObjectTagInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsObjectTagInfoEXT.html>"]
 pub struct DebugUtilsObjectTagInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -24866,9 +28007,10 @@ pub struct DebugUtilsObjectTagInfoEXT {
     pub p_tag: *const c_void,
 }
 impl ::std::default::Default for DebugUtilsObjectTagInfoEXT {
-    fn default() -> DebugUtilsObjectTagInfoEXT {
-        DebugUtilsObjectTagInfoEXT {
-            s_type: StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             object_type: ObjectType::default(),
             object_handle: u64::default(),
@@ -24878,10 +28020,13 @@ impl ::std::default::Default for DebugUtilsObjectTagInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DebugUtilsObjectTagInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_OBJECT_TAG_INFO_EXT;
+}
 impl DebugUtilsObjectTagInfoEXT {
     pub fn builder<'a>() -> DebugUtilsObjectTagInfoEXTBuilder<'a> {
         DebugUtilsObjectTagInfoEXTBuilder {
-            inner: DebugUtilsObjectTagInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24903,21 +28048,25 @@ impl<'a> ::std::ops::DerefMut for DebugUtilsObjectTagInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> {
+    #[inline]
     pub fn object_type(mut self, object_type: ObjectType) -> Self {
         self.inner.object_type = object_type;
         self
     }
+    #[inline]
     pub fn object_handle(mut self, object_handle: u64) -> Self {
         self.inner.object_handle = object_handle;
         self
     }
+    #[inline]
     pub fn tag_name(mut self, tag_name: u64) -> Self {
         self.inner.tag_name = tag_name;
         self
     }
+    #[inline]
     pub fn tag(mut self, tag: &'a [u8]) -> Self {
-        self.inner.tag_size = tag.len() as _;
-        self.inner.p_tag = tag.as_ptr() as *const c_void;
+        self.inner.tag_size = tag.len();
+        self.inner.p_tag = tag.as_ptr().cast();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -24928,8 +28077,9 @@ impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsLabelEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsLabelEXT.html>"]
 pub struct DebugUtilsLabelEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -24937,19 +28087,23 @@ pub struct DebugUtilsLabelEXT {
     pub color: [f32; 4],
 }
 impl ::std::default::Default for DebugUtilsLabelEXT {
-    fn default() -> DebugUtilsLabelEXT {
-        DebugUtilsLabelEXT {
-            s_type: StructureType::DEBUG_UTILS_LABEL_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_label_name: ::std::ptr::null(),
             color: unsafe { ::std::mem::zeroed() },
         }
     }
 }
+unsafe impl TaggedStructure for DebugUtilsLabelEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_LABEL_EXT;
+}
 impl DebugUtilsLabelEXT {
     pub fn builder<'a>() -> DebugUtilsLabelEXTBuilder<'a> {
         DebugUtilsLabelEXTBuilder {
-            inner: DebugUtilsLabelEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -24971,10 +28125,12 @@ impl<'a> ::std::ops::DerefMut for DebugUtilsLabelEXTBuilder<'a> {
     }
 }
 impl<'a> DebugUtilsLabelEXTBuilder<'a> {
+    #[inline]
     pub fn label_name(mut self, label_name: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_label_name = label_name.as_ptr();
         self
     }
+    #[inline]
     pub fn color(mut self, color: [f32; 4]) -> Self {
         self.inner.color = color;
         self
@@ -24988,7 +28144,7 @@ impl<'a> DebugUtilsLabelEXTBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCreateInfoEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCreateInfoEXT.html>"]
 pub struct DebugUtilsMessengerCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -24998,6 +28154,7 @@ pub struct DebugUtilsMessengerCreateInfoEXT {
     pub pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
     pub p_user_data: *mut c_void,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("DebugUtilsMessengerCreateInfoEXT")
@@ -25015,9 +28172,10 @@ impl fmt::Debug for DebugUtilsMessengerCreateInfoEXT {
     }
 }
 impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT {
-    fn default() -> DebugUtilsMessengerCreateInfoEXT {
-        DebugUtilsMessengerCreateInfoEXT {
-            s_type: StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DebugUtilsMessengerCreateFlagsEXT::default(),
             message_severity: DebugUtilsMessageSeverityFlagsEXT::default(),
@@ -25027,10 +28185,13 @@ impl ::std::default::Default for DebugUtilsMessengerCreateInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DebugUtilsMessengerCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+}
 impl DebugUtilsMessengerCreateInfoEXT {
     pub fn builder<'a>() -> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
         DebugUtilsMessengerCreateInfoEXTBuilder {
-            inner: DebugUtilsMessengerCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25054,18 +28215,22 @@ impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DebugUtilsMessengerCreateFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn message_severity(mut self, message_severity: DebugUtilsMessageSeverityFlagsEXT) -> Self {
         self.inner.message_severity = message_severity;
         self
     }
+    #[inline]
     pub fn message_type(mut self, message_type: DebugUtilsMessageTypeFlagsEXT) -> Self {
         self.inner.message_type = message_type;
         self
     }
+    #[inline]
     pub fn pfn_user_callback(
         mut self,
         pfn_user_callback: PFN_vkDebugUtilsMessengerCallbackEXT,
@@ -25073,6 +28238,7 @@ impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
         self.inner.pfn_user_callback = pfn_user_callback;
         self
     }
+    #[inline]
     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
         self.inner.p_user_data = user_data;
         self
@@ -25085,8 +28251,9 @@ impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugUtilsMessengerCallbackDataEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugUtilsMessengerCallbackDataEXT.html>"]
 pub struct DebugUtilsMessengerCallbackDataEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -25102,9 +28269,10 @@ pub struct DebugUtilsMessengerCallbackDataEXT {
     pub p_objects: *const DebugUtilsObjectNameInfoEXT,
 }
 impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT {
-    fn default() -> DebugUtilsMessengerCallbackDataEXT {
-        DebugUtilsMessengerCallbackDataEXT {
-            s_type: StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DebugUtilsMessengerCallbackDataFlagsEXT::default(),
             p_message_id_name: ::std::ptr::null(),
@@ -25119,10 +28287,13 @@ impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DebugUtilsMessengerCallbackDataEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT;
+}
 impl DebugUtilsMessengerCallbackDataEXT {
     pub fn builder<'a>() -> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
         DebugUtilsMessengerCallbackDataEXTBuilder {
-            inner: DebugUtilsMessengerCallbackDataEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25132,6 +28303,7 @@ pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
     inner: DebugUtilsMessengerCallbackDataEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {}
 impl<'a> ::std::ops::Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
     type Target = DebugUtilsMessengerCallbackDataEXT;
     fn deref(&self) -> &Self::Target {
@@ -25144,37 +28316,61 @@ impl<'a> ::std::ops::DerefMut for DebugUtilsMessengerCallbackDataEXTBuilder<'a>
     }
 }
 impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn message_id_name(mut self, message_id_name: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_message_id_name = message_id_name.as_ptr();
         self
     }
+    #[inline]
     pub fn message_id_number(mut self, message_id_number: i32) -> Self {
         self.inner.message_id_number = message_id_number;
         self
     }
+    #[inline]
     pub fn message(mut self, message: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_message = message.as_ptr();
         self
     }
+    #[inline]
     pub fn queue_labels(mut self, queue_labels: &'a [DebugUtilsLabelEXT]) -> Self {
         self.inner.queue_label_count = queue_labels.len() as _;
         self.inner.p_queue_labels = queue_labels.as_ptr();
         self
     }
+    #[inline]
     pub fn cmd_buf_labels(mut self, cmd_buf_labels: &'a [DebugUtilsLabelEXT]) -> Self {
         self.inner.cmd_buf_label_count = cmd_buf_labels.len() as _;
         self.inner.p_cmd_buf_labels = cmd_buf_labels.as_ptr();
         self
     }
+    #[inline]
     pub fn objects(mut self, objects: &'a [DebugUtilsObjectNameInfoEXT]) -> Self {
         self.inner.object_count = objects.len() as _;
         self.inner.p_objects = objects.as_ptr();
         self
     }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsDebugUtilsMessengerCallbackDataEXT>(
+        mut self,
+        next: &'a mut T,
+    ) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
@@ -25183,26 +28379,32 @@ impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html>"]
 pub struct PhysicalDeviceDeviceMemoryReportFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub device_memory_report: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceDeviceMemoryReportFeaturesEXT {
-    fn default() -> PhysicalDeviceDeviceMemoryReportFeaturesEXT {
-        PhysicalDeviceDeviceMemoryReportFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             device_memory_report: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDeviceMemoryReportFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT;
+}
 impl PhysicalDeviceDeviceMemoryReportFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
         PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder {
-            inner: PhysicalDeviceDeviceMemoryReportFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25231,6 +28433,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDeviceMemoryReportFeaturesEXTBui
     }
 }
 impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn device_memory_report(mut self, device_memory_report: bool) -> Self {
         self.inner.device_memory_report = device_memory_report.into();
         self
@@ -25244,7 +28447,7 @@ impl<'a> PhysicalDeviceDeviceMemoryReportFeaturesEXTBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html>"]
 pub struct DeviceDeviceMemoryReportCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -25252,6 +28455,7 @@ pub struct DeviceDeviceMemoryReportCreateInfoEXT {
     pub pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
     pub p_user_data: *mut c_void,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("DeviceDeviceMemoryReportCreateInfoEXT")
@@ -25267,9 +28471,10 @@ impl fmt::Debug for DeviceDeviceMemoryReportCreateInfoEXT {
     }
 }
 impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT {
-    fn default() -> DeviceDeviceMemoryReportCreateInfoEXT {
-        DeviceDeviceMemoryReportCreateInfoEXT {
-            s_type: StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DeviceMemoryReportFlagsEXT::default(),
             pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT::default(),
@@ -25277,10 +28482,14 @@ impl ::std::default::Default for DeviceDeviceMemoryReportCreateInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DeviceDeviceMemoryReportCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT;
+}
 impl DeviceDeviceMemoryReportCreateInfoEXT {
     pub fn builder<'a>() -> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
         DeviceDeviceMemoryReportCreateInfoEXTBuilder {
-            inner: DeviceDeviceMemoryReportCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25304,10 +28513,12 @@ impl<'a> ::std::ops::DerefMut for DeviceDeviceMemoryReportCreateInfoEXTBuilder<'
     }
 }
 impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn pfn_user_callback(
         mut self,
         pfn_user_callback: PFN_vkDeviceMemoryReportCallbackEXT,
@@ -25315,6 +28526,7 @@ impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
         self.inner.pfn_user_callback = pfn_user_callback;
         self
     }
+    #[inline]
     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
         self.inner.p_user_data = user_data;
         self
@@ -25327,8 +28539,9 @@ impl<'a> DeviceDeviceMemoryReportCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryReportCallbackDataEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportCallbackDataEXT.html>"]
 pub struct DeviceMemoryReportCallbackDataEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -25341,9 +28554,10 @@ pub struct DeviceMemoryReportCallbackDataEXT {
     pub heap_index: u32,
 }
 impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT {
-    fn default() -> DeviceMemoryReportCallbackDataEXT {
-        DeviceMemoryReportCallbackDataEXT {
-            s_type: StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             flags: DeviceMemoryReportFlagsEXT::default(),
             ty: DeviceMemoryReportEventTypeEXT::default(),
@@ -25355,10 +28569,13 @@ impl ::std::default::Default for DeviceMemoryReportCallbackDataEXT {
         }
     }
 }
+unsafe impl TaggedStructure for DeviceMemoryReportCallbackDataEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT;
+}
 impl DeviceMemoryReportCallbackDataEXT {
     pub fn builder<'a>() -> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
         DeviceMemoryReportCallbackDataEXTBuilder {
-            inner: DeviceMemoryReportCallbackDataEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25380,30 +28597,37 @@ impl<'a> ::std::ops::DerefMut for DeviceMemoryReportCallbackDataEXTBuilder<'a> {
     }
 }
 impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DeviceMemoryReportFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn ty(mut self, ty: DeviceMemoryReportEventTypeEXT) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn memory_object_id(mut self, memory_object_id: u64) -> Self {
         self.inner.memory_object_id = memory_object_id;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
     }
+    #[inline]
     pub fn object_type(mut self, object_type: ObjectType) -> Self {
         self.inner.object_type = object_type;
         self
     }
+    #[inline]
     pub fn object_handle(mut self, object_handle: u64) -> Self {
         self.inner.object_handle = object_handle;
         self
     }
+    #[inline]
     pub fn heap_index(mut self, heap_index: u32) -> Self {
         self.inner.heap_index = heap_index;
         self
@@ -25416,8 +28640,9 @@ impl<'a> DeviceMemoryReportCallbackDataEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportMemoryHostPointerInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryHostPointerInfoEXT.html>"]
 pub struct ImportMemoryHostPointerInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -25425,19 +28650,23 @@ pub struct ImportMemoryHostPointerInfoEXT {
     pub p_host_pointer: *mut c_void,
 }
 impl ::std::default::Default for ImportMemoryHostPointerInfoEXT {
-    fn default() -> ImportMemoryHostPointerInfoEXT {
-        ImportMemoryHostPointerInfoEXT {
-            s_type: StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             handle_type: ExternalMemoryHandleTypeFlags::default(),
             p_host_pointer: ::std::ptr::null_mut(),
         }
     }
 }
+unsafe impl TaggedStructure for ImportMemoryHostPointerInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_HOST_POINTER_INFO_EXT;
+}
 impl ImportMemoryHostPointerInfoEXT {
     pub fn builder<'a>() -> ImportMemoryHostPointerInfoEXTBuilder<'a> {
         ImportMemoryHostPointerInfoEXTBuilder {
-            inner: ImportMemoryHostPointerInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25461,10 +28690,12 @@ impl<'a> ::std::ops::DerefMut for ImportMemoryHostPointerInfoEXTBuilder<'a> {
     }
 }
 impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> {
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
     }
+    #[inline]
     pub fn host_pointer(mut self, host_pointer: *mut c_void) -> Self {
         self.inner.p_host_pointer = host_pointer;
         self
@@ -25477,26 +28708,31 @@ impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryHostPointerPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryHostPointerPropertiesEXT.html>"]
 pub struct MemoryHostPointerPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub memory_type_bits: u32,
 }
 impl ::std::default::Default for MemoryHostPointerPropertiesEXT {
-    fn default() -> MemoryHostPointerPropertiesEXT {
-        MemoryHostPointerPropertiesEXT {
-            s_type: StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             memory_type_bits: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryHostPointerPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_HOST_POINTER_PROPERTIES_EXT;
+}
 impl MemoryHostPointerPropertiesEXT {
     pub fn builder<'a>() -> MemoryHostPointerPropertiesEXTBuilder<'a> {
         MemoryHostPointerPropertiesEXTBuilder {
-            inner: MemoryHostPointerPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25518,6 +28754,7 @@ impl<'a> ::std::ops::DerefMut for MemoryHostPointerPropertiesEXTBuilder<'a> {
     }
 }
 impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
         self.inner.memory_type_bits = memory_type_bits;
         self
@@ -25530,26 +28767,32 @@ impl<'a> MemoryHostPointerPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html>"]
 pub struct PhysicalDeviceExternalMemoryHostPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub min_imported_host_pointer_alignment: DeviceSize,
 }
 impl ::std::default::Default for PhysicalDeviceExternalMemoryHostPropertiesEXT {
-    fn default() -> PhysicalDeviceExternalMemoryHostPropertiesEXT {
-        PhysicalDeviceExternalMemoryHostPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             min_imported_host_pointer_alignment: DeviceSize::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceExternalMemoryHostPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
+}
 impl PhysicalDeviceExternalMemoryHostPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
         PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder {
-            inner: PhysicalDeviceExternalMemoryHostPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25576,6 +28819,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryHostPropertiesEXTB
     }
 }
 impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn min_imported_host_pointer_alignment(
         mut self,
         min_imported_host_pointer_alignment: DeviceSize,
@@ -25591,8 +28835,9 @@ impl<'a> PhysicalDeviceExternalMemoryHostPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html>"]
 pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -25607,9 +28852,10 @@ pub struct PhysicalDeviceConservativeRasterizationPropertiesEXT {
     pub conservative_rasterization_post_depth_coverage: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceConservativeRasterizationPropertiesEXT {
-    fn default() -> PhysicalDeviceConservativeRasterizationPropertiesEXT {
-        PhysicalDeviceConservativeRasterizationPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             primitive_overestimation_size: f32::default(),
             max_extra_primitive_overestimation_size: f32::default(),
@@ -25623,10 +28869,14 @@ impl ::std::default::Default for PhysicalDeviceConservativeRasterizationProperti
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceConservativeRasterizationPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT;
+}
 impl PhysicalDeviceConservativeRasterizationPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
         PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder {
-            inner: PhysicalDeviceConservativeRasterizationPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25656,10 +28906,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceConservativeRasterizationPropert
     }
 }
 impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn primitive_overestimation_size(mut self, primitive_overestimation_size: f32) -> Self {
         self.inner.primitive_overestimation_size = primitive_overestimation_size;
         self
     }
+    #[inline]
     pub fn max_extra_primitive_overestimation_size(
         mut self,
         max_extra_primitive_overestimation_size: f32,
@@ -25668,6 +28920,7 @@ impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
             max_extra_primitive_overestimation_size;
         self
     }
+    #[inline]
     pub fn extra_primitive_overestimation_size_granularity(
         mut self,
         extra_primitive_overestimation_size_granularity: f32,
@@ -25676,10 +28929,12 @@ impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
             extra_primitive_overestimation_size_granularity;
         self
     }
+    #[inline]
     pub fn primitive_underestimation(mut self, primitive_underestimation: bool) -> Self {
         self.inner.primitive_underestimation = primitive_underestimation.into();
         self
     }
+    #[inline]
     pub fn conservative_point_and_line_rasterization(
         mut self,
         conservative_point_and_line_rasterization: bool,
@@ -25688,6 +28943,7 @@ impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
             conservative_point_and_line_rasterization.into();
         self
     }
+    #[inline]
     pub fn degenerate_triangles_rasterized(
         mut self,
         degenerate_triangles_rasterized: bool,
@@ -25695,10 +28951,12 @@ impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
         self.inner.degenerate_triangles_rasterized = degenerate_triangles_rasterized.into();
         self
     }
+    #[inline]
     pub fn degenerate_lines_rasterized(mut self, degenerate_lines_rasterized: bool) -> Self {
         self.inner.degenerate_lines_rasterized = degenerate_lines_rasterized.into();
         self
     }
+    #[inline]
     pub fn fully_covered_fragment_shader_input_variable(
         mut self,
         fully_covered_fragment_shader_input_variable: bool,
@@ -25707,6 +28965,7 @@ impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
             fully_covered_fragment_shader_input_variable.into();
         self
     }
+    #[inline]
     pub fn conservative_rasterization_post_depth_coverage(
         mut self,
         conservative_rasterization_post_depth_coverage: bool,
@@ -25723,26 +28982,31 @@ impl<'a> PhysicalDeviceConservativeRasterizationPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCalibratedTimestampInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCalibratedTimestampInfoEXT.html>"]
 pub struct CalibratedTimestampInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub time_domain: TimeDomainEXT,
 }
 impl ::std::default::Default for CalibratedTimestampInfoEXT {
-    fn default() -> CalibratedTimestampInfoEXT {
-        CalibratedTimestampInfoEXT {
-            s_type: StructureType::CALIBRATED_TIMESTAMP_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             time_domain: TimeDomainEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for CalibratedTimestampInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::CALIBRATED_TIMESTAMP_INFO_EXT;
+}
 impl CalibratedTimestampInfoEXT {
     pub fn builder<'a>() -> CalibratedTimestampInfoEXTBuilder<'a> {
         CalibratedTimestampInfoEXTBuilder {
-            inner: CalibratedTimestampInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25764,6 +29028,7 @@ impl<'a> ::std::ops::DerefMut for CalibratedTimestampInfoEXTBuilder<'a> {
     }
 }
 impl<'a> CalibratedTimestampInfoEXTBuilder<'a> {
+    #[inline]
     pub fn time_domain(mut self, time_domain: TimeDomainEXT) -> Self {
         self.inner.time_domain = time_domain;
         self
@@ -25776,8 +29041,9 @@ impl<'a> CalibratedTimestampInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html>"]
 pub struct PhysicalDeviceShaderCorePropertiesAMD {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -25797,9 +29063,10 @@ pub struct PhysicalDeviceShaderCorePropertiesAMD {
     pub vgpr_allocation_granularity: u32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD {
-    fn default() -> PhysicalDeviceShaderCorePropertiesAMD {
-        PhysicalDeviceShaderCorePropertiesAMD {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_engine_count: u32::default(),
             shader_arrays_per_engine_count: u32::default(),
@@ -25818,10 +29085,13 @@ impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesAMD {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderCorePropertiesAMD {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD;
+}
 impl PhysicalDeviceShaderCorePropertiesAMD {
     pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
         PhysicalDeviceShaderCorePropertiesAMDBuilder {
-            inner: PhysicalDeviceShaderCorePropertiesAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25845,58 +29115,72 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesAMDBuilder<'
     }
 }
 impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
+    #[inline]
     pub fn shader_engine_count(mut self, shader_engine_count: u32) -> Self {
         self.inner.shader_engine_count = shader_engine_count;
         self
     }
+    #[inline]
     pub fn shader_arrays_per_engine_count(mut self, shader_arrays_per_engine_count: u32) -> Self {
         self.inner.shader_arrays_per_engine_count = shader_arrays_per_engine_count;
         self
     }
+    #[inline]
     pub fn compute_units_per_shader_array(mut self, compute_units_per_shader_array: u32) -> Self {
         self.inner.compute_units_per_shader_array = compute_units_per_shader_array;
         self
     }
+    #[inline]
     pub fn simd_per_compute_unit(mut self, simd_per_compute_unit: u32) -> Self {
         self.inner.simd_per_compute_unit = simd_per_compute_unit;
         self
     }
+    #[inline]
     pub fn wavefronts_per_simd(mut self, wavefronts_per_simd: u32) -> Self {
         self.inner.wavefronts_per_simd = wavefronts_per_simd;
         self
     }
+    #[inline]
     pub fn wavefront_size(mut self, wavefront_size: u32) -> Self {
         self.inner.wavefront_size = wavefront_size;
         self
     }
+    #[inline]
     pub fn sgprs_per_simd(mut self, sgprs_per_simd: u32) -> Self {
         self.inner.sgprs_per_simd = sgprs_per_simd;
         self
     }
+    #[inline]
     pub fn min_sgpr_allocation(mut self, min_sgpr_allocation: u32) -> Self {
         self.inner.min_sgpr_allocation = min_sgpr_allocation;
         self
     }
+    #[inline]
     pub fn max_sgpr_allocation(mut self, max_sgpr_allocation: u32) -> Self {
         self.inner.max_sgpr_allocation = max_sgpr_allocation;
         self
     }
+    #[inline]
     pub fn sgpr_allocation_granularity(mut self, sgpr_allocation_granularity: u32) -> Self {
         self.inner.sgpr_allocation_granularity = sgpr_allocation_granularity;
         self
     }
+    #[inline]
     pub fn vgprs_per_simd(mut self, vgprs_per_simd: u32) -> Self {
         self.inner.vgprs_per_simd = vgprs_per_simd;
         self
     }
+    #[inline]
     pub fn min_vgpr_allocation(mut self, min_vgpr_allocation: u32) -> Self {
         self.inner.min_vgpr_allocation = min_vgpr_allocation;
         self
     }
+    #[inline]
     pub fn max_vgpr_allocation(mut self, max_vgpr_allocation: u32) -> Self {
         self.inner.max_vgpr_allocation = max_vgpr_allocation;
         self
     }
+    #[inline]
     pub fn vgpr_allocation_granularity(mut self, vgpr_allocation_granularity: u32) -> Self {
         self.inner.vgpr_allocation_granularity = vgpr_allocation_granularity;
         self
@@ -25909,8 +29193,9 @@ impl<'a> PhysicalDeviceShaderCorePropertiesAMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html>"]
 pub struct PhysicalDeviceShaderCoreProperties2AMD {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -25918,19 +29203,24 @@ pub struct PhysicalDeviceShaderCoreProperties2AMD {
     pub active_compute_unit_count: u32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderCoreProperties2AMD {
-    fn default() -> PhysicalDeviceShaderCoreProperties2AMD {
-        PhysicalDeviceShaderCoreProperties2AMD {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_core_features: ShaderCorePropertiesFlagsAMD::default(),
             active_compute_unit_count: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderCoreProperties2AMD {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
+}
 impl PhysicalDeviceShaderCoreProperties2AMD {
     pub fn builder<'a>() -> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
         PhysicalDeviceShaderCoreProperties2AMDBuilder {
-            inner: PhysicalDeviceShaderCoreProperties2AMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -25954,6 +29244,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreProperties2AMDBuilder<
     }
 }
 impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
+    #[inline]
     pub fn shader_core_features(
         mut self,
         shader_core_features: ShaderCorePropertiesFlagsAMD,
@@ -25961,6 +29252,7 @@ impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
         self.inner.shader_core_features = shader_core_features;
         self
     }
+    #[inline]
     pub fn active_compute_unit_count(mut self, active_compute_unit_count: u32) -> Self {
         self.inner.active_compute_unit_count = active_compute_unit_count;
         self
@@ -25973,8 +29265,9 @@ impl<'a> PhysicalDeviceShaderCoreProperties2AMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html>"]
 pub struct PipelineRasterizationConservativeStateCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -25983,9 +29276,10 @@ pub struct PipelineRasterizationConservativeStateCreateInfoEXT {
     pub extra_primitive_overestimation_size: f32,
 }
 impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInfoEXT {
-    fn default() -> PipelineRasterizationConservativeStateCreateInfoEXT {
-        PipelineRasterizationConservativeStateCreateInfoEXT {
-            s_type: StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineRasterizationConservativeStateCreateFlagsEXT::default(),
             conservative_rasterization_mode: ConservativeRasterizationModeEXT::default(),
@@ -25993,10 +29287,14 @@ impl ::std::default::Default for PipelineRasterizationConservativeStateCreateInf
         }
     }
 }
+unsafe impl TaggedStructure for PipelineRasterizationConservativeStateCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT;
+}
 impl PipelineRasterizationConservativeStateCreateInfoEXT {
     pub fn builder<'a>() -> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
         PipelineRasterizationConservativeStateCreateInfoEXTBuilder {
-            inner: PipelineRasterizationConservativeStateCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -26026,10 +29324,12 @@ impl<'a> ::std::ops::DerefMut for PipelineRasterizationConservativeStateCreateIn
     }
 }
 impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineRasterizationConservativeStateCreateFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn conservative_rasterization_mode(
         mut self,
         conservative_rasterization_mode: ConservativeRasterizationModeEXT,
@@ -26037,6 +29337,7 @@ impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
         self.inner.conservative_rasterization_mode = conservative_rasterization_mode;
         self
     }
+    #[inline]
     pub fn extra_primitive_overestimation_size(
         mut self,
         extra_primitive_overestimation_size: f32,
@@ -26052,8 +29353,9 @@ impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html>"]
 pub struct PhysicalDeviceDescriptorIndexingFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -26079,9 +29381,10 @@ pub struct PhysicalDeviceDescriptorIndexingFeatures {
     pub runtime_descriptor_array: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures {
-    fn default() -> PhysicalDeviceDescriptorIndexingFeatures {
-        PhysicalDeviceDescriptorIndexingFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_input_attachment_array_dynamic_indexing: Bool32::default(),
             shader_uniform_texel_buffer_array_dynamic_indexing: Bool32::default(),
@@ -26106,10 +29409,14 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingFeatures {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDescriptorIndexingFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+}
 impl PhysicalDeviceDescriptorIndexingFeatures {
     pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
         PhysicalDeviceDescriptorIndexingFeaturesBuilder {
-            inner: PhysicalDeviceDescriptorIndexingFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -26135,6 +29442,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingFeaturesBuilde
     }
 }
 impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
+    #[inline]
     pub fn shader_input_attachment_array_dynamic_indexing(
         mut self,
         shader_input_attachment_array_dynamic_indexing: bool,
@@ -26143,6 +29451,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_input_attachment_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
         mut self,
         shader_uniform_texel_buffer_array_dynamic_indexing: bool,
@@ -26152,6 +29461,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_uniform_texel_buffer_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_texel_buffer_array_dynamic_indexing(
         mut self,
         shader_storage_texel_buffer_array_dynamic_indexing: bool,
@@ -26161,6 +29471,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_storage_texel_buffer_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_uniform_buffer_array_non_uniform_indexing(
         mut self,
         shader_uniform_buffer_array_non_uniform_indexing: bool,
@@ -26169,6 +29480,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_uniform_buffer_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_sampled_image_array_non_uniform_indexing(
         mut self,
         shader_sampled_image_array_non_uniform_indexing: bool,
@@ -26177,6 +29489,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_sampled_image_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_buffer_array_non_uniform_indexing(
         mut self,
         shader_storage_buffer_array_non_uniform_indexing: bool,
@@ -26185,6 +29498,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_storage_buffer_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_image_array_non_uniform_indexing(
         mut self,
         shader_storage_image_array_non_uniform_indexing: bool,
@@ -26193,6 +29507,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_storage_image_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_input_attachment_array_non_uniform_indexing(
         mut self,
         shader_input_attachment_array_non_uniform_indexing: bool,
@@ -26202,6 +29517,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_input_attachment_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
         mut self,
         shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
@@ -26211,6 +29527,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_uniform_texel_buffer_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
         mut self,
         shader_storage_texel_buffer_array_non_uniform_indexing: bool,
@@ -26220,6 +29537,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             shader_storage_texel_buffer_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_uniform_buffer_update_after_bind(
         mut self,
         descriptor_binding_uniform_buffer_update_after_bind: bool,
@@ -26229,6 +29547,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             descriptor_binding_uniform_buffer_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_sampled_image_update_after_bind(
         mut self,
         descriptor_binding_sampled_image_update_after_bind: bool,
@@ -26238,6 +29557,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             descriptor_binding_sampled_image_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_storage_image_update_after_bind(
         mut self,
         descriptor_binding_storage_image_update_after_bind: bool,
@@ -26247,6 +29567,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             descriptor_binding_storage_image_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_storage_buffer_update_after_bind(
         mut self,
         descriptor_binding_storage_buffer_update_after_bind: bool,
@@ -26256,6 +29577,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             descriptor_binding_storage_buffer_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
         mut self,
         descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
@@ -26265,6 +29587,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             descriptor_binding_uniform_texel_buffer_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
         mut self,
         descriptor_binding_storage_texel_buffer_update_after_bind: bool,
@@ -26274,6 +29597,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             descriptor_binding_storage_texel_buffer_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_update_unused_while_pending(
         mut self,
         descriptor_binding_update_unused_while_pending: bool,
@@ -26282,6 +29606,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             descriptor_binding_update_unused_while_pending.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_partially_bound(
         mut self,
         descriptor_binding_partially_bound: bool,
@@ -26289,6 +29614,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
         self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_variable_descriptor_count(
         mut self,
         descriptor_binding_variable_descriptor_count: bool,
@@ -26297,6 +29623,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
             descriptor_binding_variable_descriptor_count.into();
         self
     }
+    #[inline]
     pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
         self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
         self
@@ -26309,8 +29636,9 @@ impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html>"]
 pub struct PhysicalDeviceDescriptorIndexingProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -26339,9 +29667,10 @@ pub struct PhysicalDeviceDescriptorIndexingProperties {
     pub max_descriptor_set_update_after_bind_input_attachments: u32,
 }
 impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties {
-    fn default() -> PhysicalDeviceDescriptorIndexingProperties {
-        PhysicalDeviceDescriptorIndexingProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_update_after_bind_descriptors_in_all_pools: u32::default(),
             shader_uniform_buffer_array_non_uniform_indexing_native: Bool32::default(),
@@ -26369,10 +29698,14 @@ impl ::std::default::Default for PhysicalDeviceDescriptorIndexingProperties {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDescriptorIndexingProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
+}
 impl PhysicalDeviceDescriptorIndexingProperties {
     pub fn builder<'a>() -> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
         PhysicalDeviceDescriptorIndexingPropertiesBuilder {
-            inner: PhysicalDeviceDescriptorIndexingProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -26399,6 +29732,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorIndexingPropertiesBuil
     }
 }
 impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
+    #[inline]
     pub fn max_update_after_bind_descriptors_in_all_pools(
         mut self,
         max_update_after_bind_descriptors_in_all_pools: u32,
@@ -26407,6 +29741,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_update_after_bind_descriptors_in_all_pools;
         self
     }
+    #[inline]
     pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
         mut self,
         shader_uniform_buffer_array_non_uniform_indexing_native: bool,
@@ -26416,6 +29751,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             shader_uniform_buffer_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn shader_sampled_image_array_non_uniform_indexing_native(
         mut self,
         shader_sampled_image_array_non_uniform_indexing_native: bool,
@@ -26425,6 +29761,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             shader_sampled_image_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn shader_storage_buffer_array_non_uniform_indexing_native(
         mut self,
         shader_storage_buffer_array_non_uniform_indexing_native: bool,
@@ -26434,6 +29771,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             shader_storage_buffer_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn shader_storage_image_array_non_uniform_indexing_native(
         mut self,
         shader_storage_image_array_non_uniform_indexing_native: bool,
@@ -26443,6 +29781,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             shader_storage_image_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn shader_input_attachment_array_non_uniform_indexing_native(
         mut self,
         shader_input_attachment_array_non_uniform_indexing_native: bool,
@@ -26452,6 +29791,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             shader_input_attachment_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn robust_buffer_access_update_after_bind(
         mut self,
         robust_buffer_access_update_after_bind: bool,
@@ -26460,10 +29800,12 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             robust_buffer_access_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
         self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_samplers(
         mut self,
         max_per_stage_descriptor_update_after_bind_samplers: u32,
@@ -26473,6 +29815,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_samplers;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
         mut self,
         max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
@@ -26482,6 +29825,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_uniform_buffers;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
         mut self,
         max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
@@ -26491,6 +29835,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_storage_buffers;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
         mut self,
         max_per_stage_descriptor_update_after_bind_sampled_images: u32,
@@ -26500,6 +29845,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_sampled_images;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_storage_images(
         mut self,
         max_per_stage_descriptor_update_after_bind_storage_images: u32,
@@ -26509,6 +29855,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_storage_images;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
         mut self,
         max_per_stage_descriptor_update_after_bind_input_attachments: u32,
@@ -26518,6 +29865,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_input_attachments;
         self
     }
+    #[inline]
     pub fn max_per_stage_update_after_bind_resources(
         mut self,
         max_per_stage_update_after_bind_resources: u32,
@@ -26526,6 +29874,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_per_stage_update_after_bind_resources;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_samplers(
         mut self,
         max_descriptor_set_update_after_bind_samplers: u32,
@@ -26534,6 +29883,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_samplers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_uniform_buffers(
         mut self,
         max_descriptor_set_update_after_bind_uniform_buffers: u32,
@@ -26543,6 +29893,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_uniform_buffers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
         mut self,
         max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
@@ -26552,6 +29903,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_storage_buffers(
         mut self,
         max_descriptor_set_update_after_bind_storage_buffers: u32,
@@ -26561,6 +29913,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_storage_buffers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
         mut self,
         max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
@@ -26570,6 +29923,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_storage_buffers_dynamic;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_sampled_images(
         mut self,
         max_descriptor_set_update_after_bind_sampled_images: u32,
@@ -26579,6 +29933,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_sampled_images;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_storage_images(
         mut self,
         max_descriptor_set_update_after_bind_storage_images: u32,
@@ -26588,6 +29943,7 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_storage_images;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_input_attachments(
         mut self,
         max_descriptor_set_update_after_bind_input_attachments: u32,
@@ -26605,8 +29961,9 @@ impl<'a> PhysicalDeviceDescriptorIndexingPropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html>"]
 pub struct DescriptorSetLayoutBindingFlagsCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -26614,19 +29971,24 @@ pub struct DescriptorSetLayoutBindingFlagsCreateInfo {
     pub p_binding_flags: *const DescriptorBindingFlags,
 }
 impl ::std::default::Default for DescriptorSetLayoutBindingFlagsCreateInfo {
-    fn default() -> DescriptorSetLayoutBindingFlagsCreateInfo {
-        DescriptorSetLayoutBindingFlagsCreateInfo {
-            s_type: StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             binding_count: u32::default(),
             p_binding_flags: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for DescriptorSetLayoutBindingFlagsCreateInfo {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
+}
 impl DescriptorSetLayoutBindingFlagsCreateInfo {
     pub fn builder<'a>() -> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
         DescriptorSetLayoutBindingFlagsCreateInfoBuilder {
-            inner: DescriptorSetLayoutBindingFlagsCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -26653,6 +30015,7 @@ impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutBindingFlagsCreateInfoBuild
     }
 }
 impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
+    #[inline]
     pub fn binding_flags(mut self, binding_flags: &'a [DescriptorBindingFlags]) -> Self {
         self.inner.binding_count = binding_flags.len() as _;
         self.inner.p_binding_flags = binding_flags.as_ptr();
@@ -26666,8 +30029,9 @@ impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html>"]
 pub struct DescriptorSetVariableDescriptorCountAllocateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -26675,19 +30039,24 @@ pub struct DescriptorSetVariableDescriptorCountAllocateInfo {
     pub p_descriptor_counts: *const u32,
 }
 impl ::std::default::Default for DescriptorSetVariableDescriptorCountAllocateInfo {
-    fn default() -> DescriptorSetVariableDescriptorCountAllocateInfo {
-        DescriptorSetVariableDescriptorCountAllocateInfo {
-            s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             descriptor_set_count: u32::default(),
             p_descriptor_counts: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for DescriptorSetVariableDescriptorCountAllocateInfo {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
+}
 impl DescriptorSetVariableDescriptorCountAllocateInfo {
     pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
         DescriptorSetVariableDescriptorCountAllocateInfoBuilder {
-            inner: DescriptorSetVariableDescriptorCountAllocateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -26714,6 +30083,7 @@ impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountAllocateIn
     }
 }
 impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
+    #[inline]
     pub fn descriptor_counts(mut self, descriptor_counts: &'a [u32]) -> Self {
         self.inner.descriptor_set_count = descriptor_counts.len() as _;
         self.inner.p_descriptor_counts = descriptor_counts.as_ptr();
@@ -26727,26 +30097,32 @@ impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html>"]
 pub struct DescriptorSetVariableDescriptorCountLayoutSupport {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_variable_descriptor_count: u32,
 }
 impl ::std::default::Default for DescriptorSetVariableDescriptorCountLayoutSupport {
-    fn default() -> DescriptorSetVariableDescriptorCountLayoutSupport {
-        DescriptorSetVariableDescriptorCountLayoutSupport {
-            s_type: StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_variable_descriptor_count: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DescriptorSetVariableDescriptorCountLayoutSupport {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
+}
 impl DescriptorSetVariableDescriptorCountLayoutSupport {
     pub fn builder<'a>() -> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
         DescriptorSetVariableDescriptorCountLayoutSupportBuilder {
-            inner: DescriptorSetVariableDescriptorCountLayoutSupport::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -26776,6 +30152,7 @@ impl<'a> ::std::ops::DerefMut for DescriptorSetVariableDescriptorCountLayoutSupp
     }
 }
 impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
+    #[inline]
     pub fn max_variable_descriptor_count(mut self, max_variable_descriptor_count: u32) -> Self {
         self.inner.max_variable_descriptor_count = max_variable_descriptor_count;
         self
@@ -26788,8 +30165,9 @@ impl<'a> DescriptorSetVariableDescriptorCountLayoutSupportBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescription2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescription2.html>"]
 pub struct AttachmentDescription2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -26804,9 +30182,10 @@ pub struct AttachmentDescription2 {
     pub final_layout: ImageLayout,
 }
 impl ::std::default::Default for AttachmentDescription2 {
-    fn default() -> AttachmentDescription2 {
-        AttachmentDescription2 {
-            s_type: StructureType::ATTACHMENT_DESCRIPTION_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: AttachmentDescriptionFlags::default(),
             format: Format::default(),
@@ -26820,10 +30199,13 @@ impl ::std::default::Default for AttachmentDescription2 {
         }
     }
 }
+unsafe impl TaggedStructure for AttachmentDescription2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_2;
+}
 impl AttachmentDescription2 {
     pub fn builder<'a>() -> AttachmentDescription2Builder<'a> {
         AttachmentDescription2Builder {
-            inner: AttachmentDescription2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -26846,38 +30228,47 @@ impl<'a> ::std::ops::DerefMut for AttachmentDescription2Builder<'a> {
     }
 }
 impl<'a> AttachmentDescription2Builder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: AttachmentDescriptionFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn samples(mut self, samples: SampleCountFlags) -> Self {
         self.inner.samples = samples;
         self
     }
+    #[inline]
     pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
         self.inner.load_op = load_op;
         self
     }
+    #[inline]
     pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
         self.inner.store_op = store_op;
         self
     }
+    #[inline]
     pub fn stencil_load_op(mut self, stencil_load_op: AttachmentLoadOp) -> Self {
         self.inner.stencil_load_op = stencil_load_op;
         self
     }
+    #[inline]
     pub fn stencil_store_op(mut self, stencil_store_op: AttachmentStoreOp) -> Self {
         self.inner.stencil_store_op = stencil_store_op;
         self
     }
+    #[inline]
     pub fn initial_layout(mut self, initial_layout: ImageLayout) -> Self {
         self.inner.initial_layout = initial_layout;
         self
     }
+    #[inline]
     pub fn final_layout(mut self, final_layout: ImageLayout) -> Self {
         self.inner.final_layout = final_layout;
         self
@@ -26889,10 +30280,10 @@ impl<'a> AttachmentDescription2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsAttachmentDescription2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -26904,8 +30295,9 @@ impl<'a> AttachmentDescription2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentReference2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReference2.html>"]
 pub struct AttachmentReference2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -26914,9 +30306,10 @@ pub struct AttachmentReference2 {
     pub aspect_mask: ImageAspectFlags,
 }
 impl ::std::default::Default for AttachmentReference2 {
-    fn default() -> AttachmentReference2 {
-        AttachmentReference2 {
-            s_type: StructureType::ATTACHMENT_REFERENCE_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             attachment: u32::default(),
             layout: ImageLayout::default(),
@@ -26924,10 +30317,13 @@ impl ::std::default::Default for AttachmentReference2 {
         }
     }
 }
+unsafe impl TaggedStructure for AttachmentReference2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_2;
+}
 impl AttachmentReference2 {
     pub fn builder<'a>() -> AttachmentReference2Builder<'a> {
         AttachmentReference2Builder {
-            inner: AttachmentReference2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -26950,14 +30346,17 @@ impl<'a> ::std::ops::DerefMut for AttachmentReference2Builder<'a> {
     }
 }
 impl<'a> AttachmentReference2Builder<'a> {
+    #[inline]
     pub fn attachment(mut self, attachment: u32) -> Self {
         self.inner.attachment = attachment;
         self
     }
+    #[inline]
     pub fn layout(mut self, layout: ImageLayout) -> Self {
         self.inner.layout = layout;
         self
     }
+    #[inline]
     pub fn aspect_mask(mut self, aspect_mask: ImageAspectFlags) -> Self {
         self.inner.aspect_mask = aspect_mask;
         self
@@ -26969,10 +30368,10 @@ impl<'a> AttachmentReference2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsAttachmentReference2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -26984,8 +30383,9 @@ impl<'a> AttachmentReference2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescription2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescription2.html>"]
 pub struct SubpassDescription2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -27002,9 +30402,10 @@ pub struct SubpassDescription2 {
     pub p_preserve_attachments: *const u32,
 }
 impl ::std::default::Default for SubpassDescription2 {
-    fn default() -> SubpassDescription2 {
-        SubpassDescription2 {
-            s_type: StructureType::SUBPASS_DESCRIPTION_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: SubpassDescriptionFlags::default(),
             pipeline_bind_point: PipelineBindPoint::default(),
@@ -27020,10 +30421,13 @@ impl ::std::default::Default for SubpassDescription2 {
         }
     }
 }
+unsafe impl TaggedStructure for SubpassDescription2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DESCRIPTION_2;
+}
 impl SubpassDescription2 {
     pub fn builder<'a>() -> SubpassDescription2Builder<'a> {
         SubpassDescription2Builder {
-            inner: SubpassDescription2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27046,33 +30450,40 @@ impl<'a> ::std::ops::DerefMut for SubpassDescription2Builder<'a> {
     }
 }
 impl<'a> SubpassDescription2Builder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: SubpassDescriptionFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn pipeline_bind_point(mut self, pipeline_bind_point: PipelineBindPoint) -> Self {
         self.inner.pipeline_bind_point = pipeline_bind_point;
         self
     }
+    #[inline]
     pub fn view_mask(mut self, view_mask: u32) -> Self {
         self.inner.view_mask = view_mask;
         self
     }
+    #[inline]
     pub fn input_attachments(mut self, input_attachments: &'a [AttachmentReference2]) -> Self {
         self.inner.input_attachment_count = input_attachments.len() as _;
         self.inner.p_input_attachments = input_attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn color_attachments(mut self, color_attachments: &'a [AttachmentReference2]) -> Self {
         self.inner.color_attachment_count = color_attachments.len() as _;
         self.inner.p_color_attachments = color_attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn resolve_attachments(mut self, resolve_attachments: &'a [AttachmentReference2]) -> Self {
         self.inner.color_attachment_count = resolve_attachments.len() as _;
         self.inner.p_resolve_attachments = resolve_attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn depth_stencil_attachment(
         mut self,
         depth_stencil_attachment: &'a AttachmentReference2,
@@ -27080,6 +30491,7 @@ impl<'a> SubpassDescription2Builder<'a> {
         self.inner.p_depth_stencil_attachment = depth_stencil_attachment;
         self
     }
+    #[inline]
     pub fn preserve_attachments(mut self, preserve_attachments: &'a [u32]) -> Self {
         self.inner.preserve_attachment_count = preserve_attachments.len() as _;
         self.inner.p_preserve_attachments = preserve_attachments.as_ptr();
@@ -27092,10 +30504,10 @@ impl<'a> SubpassDescription2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsSubpassDescription2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -27107,8 +30519,9 @@ impl<'a> SubpassDescription2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDependency2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDependency2.html>"]
 pub struct SubpassDependency2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -27122,9 +30535,10 @@ pub struct SubpassDependency2 {
     pub view_offset: i32,
 }
 impl ::std::default::Default for SubpassDependency2 {
-    fn default() -> SubpassDependency2 {
-        SubpassDependency2 {
-            s_type: StructureType::SUBPASS_DEPENDENCY_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_subpass: u32::default(),
             dst_subpass: u32::default(),
@@ -27137,10 +30551,13 @@ impl ::std::default::Default for SubpassDependency2 {
         }
     }
 }
+unsafe impl TaggedStructure for SubpassDependency2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DEPENDENCY_2;
+}
 impl SubpassDependency2 {
     pub fn builder<'a>() -> SubpassDependency2Builder<'a> {
         SubpassDependency2Builder {
-            inner: SubpassDependency2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27163,34 +30580,42 @@ impl<'a> ::std::ops::DerefMut for SubpassDependency2Builder<'a> {
     }
 }
 impl<'a> SubpassDependency2Builder<'a> {
+    #[inline]
     pub fn src_subpass(mut self, src_subpass: u32) -> Self {
         self.inner.src_subpass = src_subpass;
         self
     }
+    #[inline]
     pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
         self.inner.dst_subpass = dst_subpass;
         self
     }
+    #[inline]
     pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags) -> Self {
         self.inner.src_stage_mask = src_stage_mask;
         self
     }
+    #[inline]
     pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags) -> Self {
         self.inner.dst_stage_mask = dst_stage_mask;
         self
     }
+    #[inline]
     pub fn src_access_mask(mut self, src_access_mask: AccessFlags) -> Self {
         self.inner.src_access_mask = src_access_mask;
         self
     }
+    #[inline]
     pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags) -> Self {
         self.inner.dst_access_mask = dst_access_mask;
         self
     }
+    #[inline]
     pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
         self.inner.dependency_flags = dependency_flags;
         self
     }
+    #[inline]
     pub fn view_offset(mut self, view_offset: i32) -> Self {
         self.inner.view_offset = view_offset;
         self
@@ -27202,10 +30627,10 @@ impl<'a> SubpassDependency2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsSubpassDependency2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -27217,8 +30642,9 @@ impl<'a> SubpassDependency2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassCreateInfo2.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreateInfo2.html>"]
 pub struct RenderPassCreateInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -27233,9 +30659,10 @@ pub struct RenderPassCreateInfo2 {
     pub p_correlated_view_masks: *const u32,
 }
 impl ::std::default::Default for RenderPassCreateInfo2 {
-    fn default() -> RenderPassCreateInfo2 {
-        RenderPassCreateInfo2 {
-            s_type: StructureType::RENDER_PASS_CREATE_INFO_2,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: RenderPassCreateFlags::default(),
             attachment_count: u32::default(),
@@ -27249,10 +30676,13 @@ impl ::std::default::Default for RenderPassCreateInfo2 {
         }
     }
 }
+unsafe impl TaggedStructure for RenderPassCreateInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATE_INFO_2;
+}
 impl RenderPassCreateInfo2 {
     pub fn builder<'a>() -> RenderPassCreateInfo2Builder<'a> {
         RenderPassCreateInfo2Builder {
-            inner: RenderPassCreateInfo2::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27275,25 +30705,30 @@ impl<'a> ::std::ops::DerefMut for RenderPassCreateInfo2Builder<'a> {
     }
 }
 impl<'a> RenderPassCreateInfo2Builder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: RenderPassCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn attachments(mut self, attachments: &'a [AttachmentDescription2]) -> Self {
         self.inner.attachment_count = attachments.len() as _;
         self.inner.p_attachments = attachments.as_ptr();
         self
     }
+    #[inline]
     pub fn subpasses(mut self, subpasses: &'a [SubpassDescription2]) -> Self {
         self.inner.subpass_count = subpasses.len() as _;
         self.inner.p_subpasses = subpasses.as_ptr();
         self
     }
+    #[inline]
     pub fn dependencies(mut self, dependencies: &'a [SubpassDependency2]) -> Self {
         self.inner.dependency_count = dependencies.len() as _;
         self.inner.p_dependencies = dependencies.as_ptr();
         self
     }
+    #[inline]
     pub fn correlated_view_masks(mut self, correlated_view_masks: &'a [u32]) -> Self {
         self.inner.correlated_view_mask_count = correlated_view_masks.len() as _;
         self.inner.p_correlated_view_masks = correlated_view_masks.as_ptr();
@@ -27306,10 +30741,10 @@ impl<'a> RenderPassCreateInfo2Builder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsRenderPassCreateInfo2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -27321,26 +30756,31 @@ impl<'a> RenderPassCreateInfo2Builder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassBeginInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassBeginInfo.html>"]
 pub struct SubpassBeginInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub contents: SubpassContents,
 }
 impl ::std::default::Default for SubpassBeginInfo {
-    fn default() -> SubpassBeginInfo {
-        SubpassBeginInfo {
-            s_type: StructureType::SUBPASS_BEGIN_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             contents: SubpassContents::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SubpassBeginInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_BEGIN_INFO;
+}
 impl SubpassBeginInfo {
     pub fn builder<'a>() -> SubpassBeginInfoBuilder<'a> {
         SubpassBeginInfoBuilder {
-            inner: SubpassBeginInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27362,6 +30802,7 @@ impl<'a> ::std::ops::DerefMut for SubpassBeginInfoBuilder<'a> {
     }
 }
 impl<'a> SubpassBeginInfoBuilder<'a> {
+    #[inline]
     pub fn contents(mut self, contents: SubpassContents) -> Self {
         self.inner.contents = contents;
         self
@@ -27374,24 +30815,29 @@ impl<'a> SubpassBeginInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassEndInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassEndInfo.html>"]
 pub struct SubpassEndInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
 }
 impl ::std::default::Default for SubpassEndInfo {
-    fn default() -> SubpassEndInfo {
-        SubpassEndInfo {
-            s_type: StructureType::SUBPASS_END_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for SubpassEndInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_END_INFO;
+}
 impl SubpassEndInfo {
     pub fn builder<'a>() -> SubpassEndInfoBuilder<'a> {
         SubpassEndInfoBuilder {
-            inner: SubpassEndInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27401,6 +30847,7 @@ pub struct SubpassEndInfoBuilder<'a> {
     inner: SubpassEndInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+pub unsafe trait ExtendsSubpassEndInfo {}
 impl<'a> ::std::ops::Deref for SubpassEndInfoBuilder<'a> {
     type Target = SubpassEndInfo;
     fn deref(&self) -> &Self::Target {
@@ -27413,6 +30860,20 @@ impl<'a> ::std::ops::DerefMut for SubpassEndInfoBuilder<'a> {
     }
 }
 impl<'a> SubpassEndInfoBuilder<'a> {
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsSubpassEndInfo>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
@@ -27421,26 +30882,32 @@ impl<'a> SubpassEndInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html>"]
 pub struct PhysicalDeviceTimelineSemaphoreFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub timeline_semaphore: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreFeatures {
-    fn default() -> PhysicalDeviceTimelineSemaphoreFeatures {
-        PhysicalDeviceTimelineSemaphoreFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             timeline_semaphore: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceTimelineSemaphoreFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+}
 impl PhysicalDeviceTimelineSemaphoreFeatures {
     pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
         PhysicalDeviceTimelineSemaphoreFeaturesBuilder {
-            inner: PhysicalDeviceTimelineSemaphoreFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27466,6 +30933,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphoreFeaturesBuilder
     }
 }
 impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
+    #[inline]
     pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
         self.inner.timeline_semaphore = timeline_semaphore.into();
         self
@@ -27478,26 +30946,32 @@ impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html>"]
 pub struct PhysicalDeviceTimelineSemaphoreProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_timeline_semaphore_value_difference: u64,
 }
 impl ::std::default::Default for PhysicalDeviceTimelineSemaphoreProperties {
-    fn default() -> PhysicalDeviceTimelineSemaphoreProperties {
-        PhysicalDeviceTimelineSemaphoreProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_timeline_semaphore_value_difference: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceTimelineSemaphoreProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
+}
 impl PhysicalDeviceTimelineSemaphoreProperties {
     pub fn builder<'a>() -> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
         PhysicalDeviceTimelineSemaphorePropertiesBuilder {
-            inner: PhysicalDeviceTimelineSemaphoreProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27524,6 +30998,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceTimelineSemaphorePropertiesBuild
     }
 }
 impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
+    #[inline]
     pub fn max_timeline_semaphore_value_difference(
         mut self,
         max_timeline_semaphore_value_difference: u64,
@@ -27540,8 +31015,9 @@ impl<'a> PhysicalDeviceTimelineSemaphorePropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreTypeCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreTypeCreateInfo.html>"]
 pub struct SemaphoreTypeCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -27549,19 +31025,23 @@ pub struct SemaphoreTypeCreateInfo {
     pub initial_value: u64,
 }
 impl ::std::default::Default for SemaphoreTypeCreateInfo {
-    fn default() -> SemaphoreTypeCreateInfo {
-        SemaphoreTypeCreateInfo {
-            s_type: StructureType::SEMAPHORE_TYPE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             semaphore_type: SemaphoreType::default(),
             initial_value: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SemaphoreTypeCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_TYPE_CREATE_INFO;
+}
 impl SemaphoreTypeCreateInfo {
     pub fn builder<'a>() -> SemaphoreTypeCreateInfoBuilder<'a> {
         SemaphoreTypeCreateInfoBuilder {
-            inner: SemaphoreTypeCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27587,10 +31067,12 @@ impl<'a> ::std::ops::DerefMut for SemaphoreTypeCreateInfoBuilder<'a> {
     }
 }
 impl<'a> SemaphoreTypeCreateInfoBuilder<'a> {
+    #[inline]
     pub fn semaphore_type(mut self, semaphore_type: SemaphoreType) -> Self {
         self.inner.semaphore_type = semaphore_type;
         self
     }
+    #[inline]
     pub fn initial_value(mut self, initial_value: u64) -> Self {
         self.inner.initial_value = initial_value;
         self
@@ -27603,8 +31085,9 @@ impl<'a> SemaphoreTypeCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTimelineSemaphoreSubmitInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTimelineSemaphoreSubmitInfo.html>"]
 pub struct TimelineSemaphoreSubmitInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -27614,9 +31097,10 @@ pub struct TimelineSemaphoreSubmitInfo {
     pub p_signal_semaphore_values: *const u64,
 }
 impl ::std::default::Default for TimelineSemaphoreSubmitInfo {
-    fn default() -> TimelineSemaphoreSubmitInfo {
-        TimelineSemaphoreSubmitInfo {
-            s_type: StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             wait_semaphore_value_count: u32::default(),
             p_wait_semaphore_values: ::std::ptr::null(),
@@ -27625,10 +31109,13 @@ impl ::std::default::Default for TimelineSemaphoreSubmitInfo {
         }
     }
 }
+unsafe impl TaggedStructure for TimelineSemaphoreSubmitInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::TIMELINE_SEMAPHORE_SUBMIT_INFO;
+}
 impl TimelineSemaphoreSubmitInfo {
     pub fn builder<'a>() -> TimelineSemaphoreSubmitInfoBuilder<'a> {
         TimelineSemaphoreSubmitInfoBuilder {
-            inner: TimelineSemaphoreSubmitInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27654,11 +31141,13 @@ impl<'a> ::std::ops::DerefMut for TimelineSemaphoreSubmitInfoBuilder<'a> {
     }
 }
 impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> {
+    #[inline]
     pub fn wait_semaphore_values(mut self, wait_semaphore_values: &'a [u64]) -> Self {
         self.inner.wait_semaphore_value_count = wait_semaphore_values.len() as _;
         self.inner.p_wait_semaphore_values = wait_semaphore_values.as_ptr();
         self
     }
+    #[inline]
     pub fn signal_semaphore_values(mut self, signal_semaphore_values: &'a [u64]) -> Self {
         self.inner.signal_semaphore_value_count = signal_semaphore_values.len() as _;
         self.inner.p_signal_semaphore_values = signal_semaphore_values.as_ptr();
@@ -27672,8 +31161,9 @@ impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreWaitInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreWaitInfo.html>"]
 pub struct SemaphoreWaitInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -27683,9 +31173,10 @@ pub struct SemaphoreWaitInfo {
     pub p_values: *const u64,
 }
 impl ::std::default::Default for SemaphoreWaitInfo {
-    fn default() -> SemaphoreWaitInfo {
-        SemaphoreWaitInfo {
-            s_type: StructureType::SEMAPHORE_WAIT_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: SemaphoreWaitFlags::default(),
             semaphore_count: u32::default(),
@@ -27694,10 +31185,13 @@ impl ::std::default::Default for SemaphoreWaitInfo {
         }
     }
 }
+unsafe impl TaggedStructure for SemaphoreWaitInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_WAIT_INFO;
+}
 impl SemaphoreWaitInfo {
     pub fn builder<'a>() -> SemaphoreWaitInfoBuilder<'a> {
         SemaphoreWaitInfoBuilder {
-            inner: SemaphoreWaitInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27719,15 +31213,18 @@ impl<'a> ::std::ops::DerefMut for SemaphoreWaitInfoBuilder<'a> {
     }
 }
 impl<'a> SemaphoreWaitInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: SemaphoreWaitFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn semaphores(mut self, semaphores: &'a [Semaphore]) -> Self {
         self.inner.semaphore_count = semaphores.len() as _;
         self.inner.p_semaphores = semaphores.as_ptr();
         self
     }
+    #[inline]
     pub fn values(mut self, values: &'a [u64]) -> Self {
         self.inner.semaphore_count = values.len() as _;
         self.inner.p_values = values.as_ptr();
@@ -27741,8 +31238,9 @@ impl<'a> SemaphoreWaitInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreSignalInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSignalInfo.html>"]
 pub struct SemaphoreSignalInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -27750,19 +31248,23 @@ pub struct SemaphoreSignalInfo {
     pub value: u64,
 }
 impl ::std::default::Default for SemaphoreSignalInfo {
-    fn default() -> SemaphoreSignalInfo {
-        SemaphoreSignalInfo {
-            s_type: StructureType::SEMAPHORE_SIGNAL_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             semaphore: Semaphore::default(),
             value: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SemaphoreSignalInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_SIGNAL_INFO;
+}
 impl SemaphoreSignalInfo {
     pub fn builder<'a>() -> SemaphoreSignalInfoBuilder<'a> {
         SemaphoreSignalInfoBuilder {
-            inner: SemaphoreSignalInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27784,10 +31286,12 @@ impl<'a> ::std::ops::DerefMut for SemaphoreSignalInfoBuilder<'a> {
     }
 }
 impl<'a> SemaphoreSignalInfoBuilder<'a> {
+    #[inline]
     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
         self.inner.semaphore = semaphore;
         self
     }
+    #[inline]
     pub fn value(mut self, value: u64) -> Self {
         self.inner.value = value;
         self
@@ -27800,8 +31304,9 @@ impl<'a> SemaphoreSignalInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputBindingDivisorDescriptionEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDivisorDescriptionEXT.html>"]
 pub struct VertexInputBindingDivisorDescriptionEXT {
     pub binding: u32,
     pub divisor: u32,
@@ -27809,7 +31314,7 @@ pub struct VertexInputBindingDivisorDescriptionEXT {
 impl VertexInputBindingDivisorDescriptionEXT {
     pub fn builder<'a>() -> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
         VertexInputBindingDivisorDescriptionEXTBuilder {
-            inner: VertexInputBindingDivisorDescriptionEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27831,10 +31336,12 @@ impl<'a> ::std::ops::DerefMut for VertexInputBindingDivisorDescriptionEXTBuilder
     }
 }
 impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
+    #[inline]
     pub fn binding(mut self, binding: u32) -> Self {
         self.inner.binding = binding;
         self
     }
+    #[inline]
     pub fn divisor(mut self, divisor: u32) -> Self {
         self.inner.divisor = divisor;
         self
@@ -27847,8 +31354,9 @@ impl<'a> VertexInputBindingDivisorDescriptionEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineVertexInputDivisorStateCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineVertexInputDivisorStateCreateInfoEXT.html>"]
 pub struct PipelineVertexInputDivisorStateCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -27856,19 +31364,24 @@ pub struct PipelineVertexInputDivisorStateCreateInfoEXT {
     pub p_vertex_binding_divisors: *const VertexInputBindingDivisorDescriptionEXT,
 }
 impl ::std::default::Default for PipelineVertexInputDivisorStateCreateInfoEXT {
-    fn default() -> PipelineVertexInputDivisorStateCreateInfoEXT {
-        PipelineVertexInputDivisorStateCreateInfoEXT {
-            s_type: StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             vertex_binding_divisor_count: u32::default(),
             p_vertex_binding_divisors: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineVertexInputDivisorStateCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT;
+}
 impl PipelineVertexInputDivisorStateCreateInfoEXT {
     pub fn builder<'a>() -> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
         PipelineVertexInputDivisorStateCreateInfoEXTBuilder {
-            inner: PipelineVertexInputDivisorStateCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27898,6 +31411,7 @@ impl<'a> ::std::ops::DerefMut for PipelineVertexInputDivisorStateCreateInfoEXTBu
     }
 }
 impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn vertex_binding_divisors(
         mut self,
         vertex_binding_divisors: &'a [VertexInputBindingDivisorDescriptionEXT],
@@ -27914,26 +31428,32 @@ impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html>"]
 pub struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_vertex_attrib_divisor: u32,
 }
 impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
-    fn default() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
-        PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_vertex_attrib_divisor: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT;
+}
 impl PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
         PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder {
-            inner: PhysicalDeviceVertexAttributeDivisorPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -27960,6 +31480,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorProperties
     }
 }
 impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn max_vertex_attrib_divisor(mut self, max_vertex_attrib_divisor: u32) -> Self {
         self.inner.max_vertex_attrib_divisor = max_vertex_attrib_divisor;
         self
@@ -27972,8 +31493,9 @@ impl<'a> PhysicalDeviceVertexAttributeDivisorPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html>"]
 pub struct PhysicalDevicePCIBusInfoPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -27983,9 +31505,10 @@ pub struct PhysicalDevicePCIBusInfoPropertiesEXT {
     pub pci_function: u32,
 }
 impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT {
-    fn default() -> PhysicalDevicePCIBusInfoPropertiesEXT {
-        PhysicalDevicePCIBusInfoPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             pci_domain: u32::default(),
             pci_bus: u32::default(),
@@ -27994,10 +31517,14 @@ impl ::std::default::Default for PhysicalDevicePCIBusInfoPropertiesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePCIBusInfoPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT;
+}
 impl PhysicalDevicePCIBusInfoPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
         PhysicalDevicePCIBusInfoPropertiesEXTBuilder {
-            inner: PhysicalDevicePCIBusInfoPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28021,18 +31548,22 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'
     }
 }
 impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn pci_domain(mut self, pci_domain: u32) -> Self {
         self.inner.pci_domain = pci_domain;
         self
     }
+    #[inline]
     pub fn pci_bus(mut self, pci_bus: u32) -> Self {
         self.inner.pci_bus = pci_bus;
         self
     }
+    #[inline]
     pub fn pci_device(mut self, pci_device: u32) -> Self {
         self.inner.pci_device = pci_device;
         self
     }
+    #[inline]
     pub fn pci_function(mut self, pci_function: u32) -> Self {
         self.inner.pci_function = pci_function;
         self
@@ -28045,26 +31576,32 @@ impl<'a> PhysicalDevicePCIBusInfoPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImportAndroidHardwareBufferInfoANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportAndroidHardwareBufferInfoANDROID.html>"]
 pub struct ImportAndroidHardwareBufferInfoANDROID {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub buffer: *mut AHardwareBuffer,
 }
 impl ::std::default::Default for ImportAndroidHardwareBufferInfoANDROID {
-    fn default() -> ImportAndroidHardwareBufferInfoANDROID {
-        ImportAndroidHardwareBufferInfoANDROID {
-            s_type: StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             buffer: ::std::ptr::null_mut(),
         }
     }
 }
+unsafe impl TaggedStructure for ImportAndroidHardwareBufferInfoANDROID {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
+}
 impl ImportAndroidHardwareBufferInfoANDROID {
     pub fn builder<'a>() -> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
         ImportAndroidHardwareBufferInfoANDROIDBuilder {
-            inner: ImportAndroidHardwareBufferInfoANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28088,6 +31625,7 @@ impl<'a> ::std::ops::DerefMut for ImportAndroidHardwareBufferInfoANDROIDBuilder<
     }
 }
 impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
+    #[inline]
     pub fn buffer(mut self, buffer: *mut AHardwareBuffer) -> Self {
         self.inner.buffer = buffer;
         self
@@ -28100,26 +31638,31 @@ impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidHardwareBufferUsageANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferUsageANDROID.html>"]
 pub struct AndroidHardwareBufferUsageANDROID {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub android_hardware_buffer_usage: u64,
 }
 impl ::std::default::Default for AndroidHardwareBufferUsageANDROID {
-    fn default() -> AndroidHardwareBufferUsageANDROID {
-        AndroidHardwareBufferUsageANDROID {
-            s_type: StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             android_hardware_buffer_usage: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AndroidHardwareBufferUsageANDROID {
+    const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_HARDWARE_BUFFER_USAGE_ANDROID;
+}
 impl AndroidHardwareBufferUsageANDROID {
     pub fn builder<'a>() -> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
         AndroidHardwareBufferUsageANDROIDBuilder {
-            inner: AndroidHardwareBufferUsageANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28143,6 +31686,7 @@ impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferUsageANDROIDBuilder<'a> {
     }
 }
 impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
+    #[inline]
     pub fn android_hardware_buffer_usage(mut self, android_hardware_buffer_usage: u64) -> Self {
         self.inner.android_hardware_buffer_usage = android_hardware_buffer_usage;
         self
@@ -28155,8 +31699,9 @@ impl<'a> AndroidHardwareBufferUsageANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidHardwareBufferPropertiesANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferPropertiesANDROID.html>"]
 pub struct AndroidHardwareBufferPropertiesANDROID {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -28164,19 +31709,23 @@ pub struct AndroidHardwareBufferPropertiesANDROID {
     pub memory_type_bits: u32,
 }
 impl ::std::default::Default for AndroidHardwareBufferPropertiesANDROID {
-    fn default() -> AndroidHardwareBufferPropertiesANDROID {
-        AndroidHardwareBufferPropertiesANDROID {
-            s_type: StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             allocation_size: DeviceSize::default(),
             memory_type_bits: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AndroidHardwareBufferPropertiesANDROID {
+    const STRUCTURE_TYPE: StructureType = StructureType::ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID;
+}
 impl AndroidHardwareBufferPropertiesANDROID {
     pub fn builder<'a>() -> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
         AndroidHardwareBufferPropertiesANDROIDBuilder {
-            inner: AndroidHardwareBufferPropertiesANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28199,10 +31748,12 @@ impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferPropertiesANDROIDBuilder<
     }
 }
 impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
+    #[inline]
     pub fn allocation_size(mut self, allocation_size: DeviceSize) -> Self {
         self.inner.allocation_size = allocation_size;
         self
     }
+    #[inline]
     pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
         self.inner.memory_type_bits = memory_type_bits;
         self
@@ -28217,10 +31768,10 @@ impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -28232,26 +31783,32 @@ impl<'a> AndroidHardwareBufferPropertiesANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html>"]
 pub struct MemoryGetAndroidHardwareBufferInfoANDROID {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub memory: DeviceMemory,
 }
 impl ::std::default::Default for MemoryGetAndroidHardwareBufferInfoANDROID {
-    fn default() -> MemoryGetAndroidHardwareBufferInfoANDROID {
-        MemoryGetAndroidHardwareBufferInfoANDROID {
-            s_type: StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             memory: DeviceMemory::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryGetAndroidHardwareBufferInfoANDROID {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
+}
 impl MemoryGetAndroidHardwareBufferInfoANDROID {
     pub fn builder<'a>() -> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
         MemoryGetAndroidHardwareBufferInfoANDROIDBuilder {
-            inner: MemoryGetAndroidHardwareBufferInfoANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28273,6 +31830,7 @@ impl<'a> ::std::ops::DerefMut for MemoryGetAndroidHardwareBufferInfoANDROIDBuild
     }
 }
 impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
@@ -28285,8 +31843,9 @@ impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html>"]
 pub struct AndroidHardwareBufferFormatPropertiesANDROID {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -28300,9 +31859,10 @@ pub struct AndroidHardwareBufferFormatPropertiesANDROID {
     pub suggested_y_chroma_offset: ChromaLocation,
 }
 impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID {
-    fn default() -> AndroidHardwareBufferFormatPropertiesANDROID {
-        AndroidHardwareBufferFormatPropertiesANDROID {
-            s_type: StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             format: Format::default(),
             external_format: u64::default(),
@@ -28315,10 +31875,14 @@ impl ::std::default::Default for AndroidHardwareBufferFormatPropertiesANDROID {
         }
     }
 }
+unsafe impl TaggedStructure for AndroidHardwareBufferFormatPropertiesANDROID {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID;
+}
 impl AndroidHardwareBufferFormatPropertiesANDROID {
     pub fn builder<'a>() -> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
         AndroidHardwareBufferFormatPropertiesANDROIDBuilder {
-            inner: AndroidHardwareBufferFormatPropertiesANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28348,18 +31912,22 @@ impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatPropertiesANDROIDBu
     }
 }
 impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn external_format(mut self, external_format: u64) -> Self {
         self.inner.external_format = external_format;
         self
     }
+    #[inline]
     pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self {
         self.inner.format_features = format_features;
         self
     }
+    #[inline]
     pub fn sampler_ycbcr_conversion_components(
         mut self,
         sampler_ycbcr_conversion_components: ComponentMapping,
@@ -28367,6 +31935,7 @@ impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
         self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
         self
     }
+    #[inline]
     pub fn suggested_ycbcr_model(
         mut self,
         suggested_ycbcr_model: SamplerYcbcrModelConversion,
@@ -28374,14 +31943,17 @@ impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
         self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
         self
     }
+    #[inline]
     pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
         self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
         self
     }
+    #[inline]
     pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
         self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
         self
     }
+    #[inline]
     pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
         self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
         self
@@ -28394,26 +31966,32 @@ impl<'a> AndroidHardwareBufferFormatPropertiesANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html>"]
 pub struct CommandBufferInheritanceConditionalRenderingInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub conditional_rendering_enable: Bool32,
 }
 impl ::std::default::Default for CommandBufferInheritanceConditionalRenderingInfoEXT {
-    fn default() -> CommandBufferInheritanceConditionalRenderingInfoEXT {
-        CommandBufferInheritanceConditionalRenderingInfoEXT {
-            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             conditional_rendering_enable: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for CommandBufferInheritanceConditionalRenderingInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT;
+}
 impl CommandBufferInheritanceConditionalRenderingInfoEXT {
     pub fn builder<'a>() -> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
         CommandBufferInheritanceConditionalRenderingInfoEXTBuilder {
-            inner: CommandBufferInheritanceConditionalRenderingInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28443,6 +32021,7 @@ impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceConditionalRenderingIn
     }
 }
 impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
+    #[inline]
     pub fn conditional_rendering_enable(mut self, conditional_rendering_enable: bool) -> Self {
         self.inner.conditional_rendering_enable = conditional_rendering_enable.into();
         self
@@ -28455,26 +32034,31 @@ impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkExternalFormatANDROID.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExternalFormatANDROID.html>"]
 pub struct ExternalFormatANDROID {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub external_format: u64,
 }
 impl ::std::default::Default for ExternalFormatANDROID {
-    fn default() -> ExternalFormatANDROID {
-        ExternalFormatANDROID {
-            s_type: StructureType::EXTERNAL_FORMAT_ANDROID,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             external_format: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ExternalFormatANDROID {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXTERNAL_FORMAT_ANDROID;
+}
 impl ExternalFormatANDROID {
     pub fn builder<'a>() -> ExternalFormatANDROIDBuilder<'a> {
         ExternalFormatANDROIDBuilder {
-            inner: ExternalFormatANDROID::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28500,6 +32084,7 @@ impl<'a> ::std::ops::DerefMut for ExternalFormatANDROIDBuilder<'a> {
     }
 }
 impl<'a> ExternalFormatANDROIDBuilder<'a> {
+    #[inline]
     pub fn external_format(mut self, external_format: u64) -> Self {
         self.inner.external_format = external_format;
         self
@@ -28512,8 +32097,9 @@ impl<'a> ExternalFormatANDROIDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice8BitStorageFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice8BitStorageFeatures.html>"]
 pub struct PhysicalDevice8BitStorageFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -28522,9 +32108,10 @@ pub struct PhysicalDevice8BitStorageFeatures {
     pub storage_push_constant8: Bool32,
 }
 impl ::std::default::Default for PhysicalDevice8BitStorageFeatures {
-    fn default() -> PhysicalDevice8BitStorageFeatures {
-        PhysicalDevice8BitStorageFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             storage_buffer8_bit_access: Bool32::default(),
             uniform_and_storage_buffer8_bit_access: Bool32::default(),
@@ -28532,10 +32119,13 @@ impl ::std::default::Default for PhysicalDevice8BitStorageFeatures {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevice8BitStorageFeatures {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
+}
 impl PhysicalDevice8BitStorageFeatures {
     pub fn builder<'a>() -> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
         PhysicalDevice8BitStorageFeaturesBuilder {
-            inner: PhysicalDevice8BitStorageFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28561,10 +32151,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
+    #[inline]
     pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
         self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
         self
     }
+    #[inline]
     pub fn uniform_and_storage_buffer8_bit_access(
         mut self,
         uniform_and_storage_buffer8_bit_access: bool,
@@ -28573,6 +32165,7 @@ impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
             uniform_and_storage_buffer8_bit_access.into();
         self
     }
+    #[inline]
     pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
         self.inner.storage_push_constant8 = storage_push_constant8.into();
         self
@@ -28585,8 +32178,9 @@ impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html>"]
 pub struct PhysicalDeviceConditionalRenderingFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -28594,19 +32188,24 @@ pub struct PhysicalDeviceConditionalRenderingFeaturesEXT {
     pub inherited_conditional_rendering: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceConditionalRenderingFeaturesEXT {
-    fn default() -> PhysicalDeviceConditionalRenderingFeaturesEXT {
-        PhysicalDeviceConditionalRenderingFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             conditional_rendering: Bool32::default(),
             inherited_conditional_rendering: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceConditionalRenderingFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT;
+}
 impl PhysicalDeviceConditionalRenderingFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
         PhysicalDeviceConditionalRenderingFeaturesEXTBuilder {
-            inner: PhysicalDeviceConditionalRenderingFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28635,10 +32234,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceConditionalRenderingFeaturesEXTB
     }
 }
 impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn conditional_rendering(mut self, conditional_rendering: bool) -> Self {
         self.inner.conditional_rendering = conditional_rendering.into();
         self
     }
+    #[inline]
     pub fn inherited_conditional_rendering(
         mut self,
         inherited_conditional_rendering: bool,
@@ -28654,8 +32255,9 @@ impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html>"]
 pub struct PhysicalDeviceVulkanMemoryModelFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -28664,9 +32266,10 @@ pub struct PhysicalDeviceVulkanMemoryModelFeatures {
     pub vulkan_memory_model_availability_visibility_chains: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures {
-    fn default() -> PhysicalDeviceVulkanMemoryModelFeatures {
-        PhysicalDeviceVulkanMemoryModelFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             vulkan_memory_model: Bool32::default(),
             vulkan_memory_model_device_scope: Bool32::default(),
@@ -28674,10 +32277,14 @@ impl ::std::default::Default for PhysicalDeviceVulkanMemoryModelFeatures {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVulkanMemoryModelFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
+}
 impl PhysicalDeviceVulkanMemoryModelFeatures {
     pub fn builder<'a>() -> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
         PhysicalDeviceVulkanMemoryModelFeaturesBuilder {
-            inner: PhysicalDeviceVulkanMemoryModelFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28703,10 +32310,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkanMemoryModelFeaturesBuilder
     }
 }
 impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
+    #[inline]
     pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
         self.inner.vulkan_memory_model = vulkan_memory_model.into();
         self
     }
+    #[inline]
     pub fn vulkan_memory_model_device_scope(
         mut self,
         vulkan_memory_model_device_scope: bool,
@@ -28714,6 +32323,7 @@ impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
         self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
         self
     }
+    #[inline]
     pub fn vulkan_memory_model_availability_visibility_chains(
         mut self,
         vulkan_memory_model_availability_visibility_chains: bool,
@@ -28731,8 +32341,9 @@ impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html>"]
 pub struct PhysicalDeviceShaderAtomicInt64Features {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -28740,19 +32351,24 @@ pub struct PhysicalDeviceShaderAtomicInt64Features {
     pub shader_shared_int64_atomics: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderAtomicInt64Features {
-    fn default() -> PhysicalDeviceShaderAtomicInt64Features {
-        PhysicalDeviceShaderAtomicInt64Features {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_buffer_int64_atomics: Bool32::default(),
             shader_shared_int64_atomics: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicInt64Features {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
+}
 impl PhysicalDeviceShaderAtomicInt64Features {
     pub fn builder<'a>() -> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
         PhysicalDeviceShaderAtomicInt64FeaturesBuilder {
-            inner: PhysicalDeviceShaderAtomicInt64Features::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28778,10 +32394,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicInt64FeaturesBuilder
     }
 }
 impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
+    #[inline]
     pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
         self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
         self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
         self
@@ -28794,8 +32412,9 @@ impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html>"]
 pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -28813,9 +32432,10 @@ pub struct PhysicalDeviceShaderAtomicFloatFeaturesEXT {
     pub sparse_image_float32_atomic_add: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT {
-    fn default() -> PhysicalDeviceShaderAtomicFloatFeaturesEXT {
-        PhysicalDeviceShaderAtomicFloatFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_buffer_float32_atomics: Bool32::default(),
             shader_buffer_float32_atomic_add: Bool32::default(),
@@ -28832,10 +32452,14 @@ impl ::std::default::Default for PhysicalDeviceShaderAtomicFloatFeaturesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicFloatFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT;
+}
 impl PhysicalDeviceShaderAtomicFloatFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
         PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder {
-            inner: PhysicalDeviceShaderAtomicFloatFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -28864,10 +32488,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloatFeaturesEXTBuil
     }
 }
 impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn shader_buffer_float32_atomics(mut self, shader_buffer_float32_atomics: bool) -> Self {
         self.inner.shader_buffer_float32_atomics = shader_buffer_float32_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_buffer_float32_atomic_add(
         mut self,
         shader_buffer_float32_atomic_add: bool,
@@ -28875,10 +32501,12 @@ impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
         self.inner.shader_buffer_float32_atomic_add = shader_buffer_float32_atomic_add.into();
         self
     }
+    #[inline]
     pub fn shader_buffer_float64_atomics(mut self, shader_buffer_float64_atomics: bool) -> Self {
         self.inner.shader_buffer_float64_atomics = shader_buffer_float64_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_buffer_float64_atomic_add(
         mut self,
         shader_buffer_float64_atomic_add: bool,
@@ -28886,10 +32514,12 @@ impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
         self.inner.shader_buffer_float64_atomic_add = shader_buffer_float64_atomic_add.into();
         self
     }
+    #[inline]
     pub fn shader_shared_float32_atomics(mut self, shader_shared_float32_atomics: bool) -> Self {
         self.inner.shader_shared_float32_atomics = shader_shared_float32_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_shared_float32_atomic_add(
         mut self,
         shader_shared_float32_atomic_add: bool,
@@ -28897,10 +32527,12 @@ impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
         self.inner.shader_shared_float32_atomic_add = shader_shared_float32_atomic_add.into();
         self
     }
+    #[inline]
     pub fn shader_shared_float64_atomics(mut self, shader_shared_float64_atomics: bool) -> Self {
         self.inner.shader_shared_float64_atomics = shader_shared_float64_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_shared_float64_atomic_add(
         mut self,
         shader_shared_float64_atomic_add: bool,
@@ -28908,10 +32540,12 @@ impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
         self.inner.shader_shared_float64_atomic_add = shader_shared_float64_atomic_add.into();
         self
     }
+    #[inline]
     pub fn shader_image_float32_atomics(mut self, shader_image_float32_atomics: bool) -> Self {
         self.inner.shader_image_float32_atomics = shader_image_float32_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_image_float32_atomic_add(
         mut self,
         shader_image_float32_atomic_add: bool,
@@ -28919,10 +32553,12 @@ impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
         self.inner.shader_image_float32_atomic_add = shader_image_float32_atomic_add.into();
         self
     }
+    #[inline]
     pub fn sparse_image_float32_atomics(mut self, sparse_image_float32_atomics: bool) -> Self {
         self.inner.sparse_image_float32_atomics = sparse_image_float32_atomics.into();
         self
     }
+    #[inline]
     pub fn sparse_image_float32_atomic_add(
         mut self,
         sparse_image_float32_atomic_add: bool,
@@ -28938,8 +32574,9 @@ impl<'a> PhysicalDeviceShaderAtomicFloatFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html>"]
 pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -28957,9 +32594,10 @@ pub struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
     pub sparse_image_float32_atomic_min_max: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
-    fn default() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
-        PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_buffer_float16_atomics: Bool32::default(),
             shader_buffer_float16_atomic_add: Bool32::default(),
@@ -28976,10 +32614,14 @@ impl ::std::default::Default for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT;
+}
 impl PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
         PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder {
-            inner: PhysicalDeviceShaderAtomicFloat2FeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29008,10 +32650,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderAtomicFloat2FeaturesEXTBui
     }
 }
 impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn shader_buffer_float16_atomics(mut self, shader_buffer_float16_atomics: bool) -> Self {
         self.inner.shader_buffer_float16_atomics = shader_buffer_float16_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_buffer_float16_atomic_add(
         mut self,
         shader_buffer_float16_atomic_add: bool,
@@ -29019,6 +32663,7 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
         self.inner.shader_buffer_float16_atomic_add = shader_buffer_float16_atomic_add.into();
         self
     }
+    #[inline]
     pub fn shader_buffer_float16_atomic_min_max(
         mut self,
         shader_buffer_float16_atomic_min_max: bool,
@@ -29027,6 +32672,7 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
             shader_buffer_float16_atomic_min_max.into();
         self
     }
+    #[inline]
     pub fn shader_buffer_float32_atomic_min_max(
         mut self,
         shader_buffer_float32_atomic_min_max: bool,
@@ -29035,6 +32681,7 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
             shader_buffer_float32_atomic_min_max.into();
         self
     }
+    #[inline]
     pub fn shader_buffer_float64_atomic_min_max(
         mut self,
         shader_buffer_float64_atomic_min_max: bool,
@@ -29043,10 +32690,12 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
             shader_buffer_float64_atomic_min_max.into();
         self
     }
+    #[inline]
     pub fn shader_shared_float16_atomics(mut self, shader_shared_float16_atomics: bool) -> Self {
         self.inner.shader_shared_float16_atomics = shader_shared_float16_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_shared_float16_atomic_add(
         mut self,
         shader_shared_float16_atomic_add: bool,
@@ -29054,6 +32703,7 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
         self.inner.shader_shared_float16_atomic_add = shader_shared_float16_atomic_add.into();
         self
     }
+    #[inline]
     pub fn shader_shared_float16_atomic_min_max(
         mut self,
         shader_shared_float16_atomic_min_max: bool,
@@ -29062,6 +32712,7 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
             shader_shared_float16_atomic_min_max.into();
         self
     }
+    #[inline]
     pub fn shader_shared_float32_atomic_min_max(
         mut self,
         shader_shared_float32_atomic_min_max: bool,
@@ -29070,6 +32721,7 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
             shader_shared_float32_atomic_min_max.into();
         self
     }
+    #[inline]
     pub fn shader_shared_float64_atomic_min_max(
         mut self,
         shader_shared_float64_atomic_min_max: bool,
@@ -29078,6 +32730,7 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
             shader_shared_float64_atomic_min_max.into();
         self
     }
+    #[inline]
     pub fn shader_image_float32_atomic_min_max(
         mut self,
         shader_image_float32_atomic_min_max: bool,
@@ -29085,6 +32738,7 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
         self.inner.shader_image_float32_atomic_min_max = shader_image_float32_atomic_min_max.into();
         self
     }
+    #[inline]
     pub fn sparse_image_float32_atomic_min_max(
         mut self,
         sparse_image_float32_atomic_min_max: bool,
@@ -29100,8 +32754,9 @@ impl<'a> PhysicalDeviceShaderAtomicFloat2FeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT.html>"]
 pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -29109,19 +32764,24 @@ pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
     pub vertex_attribute_instance_rate_zero_divisor: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
-    fn default() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
-        PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             vertex_attribute_instance_rate_divisor: Bool32::default(),
             vertex_attribute_instance_rate_zero_divisor: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT;
+}
 impl PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
         PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder {
-            inner: PhysicalDeviceVertexAttributeDivisorFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29150,6 +32810,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexAttributeDivisorFeaturesEX
     }
 }
 impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn vertex_attribute_instance_rate_divisor(
         mut self,
         vertex_attribute_instance_rate_divisor: bool,
@@ -29158,6 +32819,7 @@ impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
             vertex_attribute_instance_rate_divisor.into();
         self
     }
+    #[inline]
     pub fn vertex_attribute_instance_rate_zero_divisor(
         mut self,
         vertex_attribute_instance_rate_zero_divisor: bool,
@@ -29174,26 +32836,31 @@ impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyCheckpointPropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointPropertiesNV.html>"]
 pub struct QueueFamilyCheckpointPropertiesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub checkpoint_execution_stage_mask: PipelineStageFlags,
 }
 impl ::std::default::Default for QueueFamilyCheckpointPropertiesNV {
-    fn default() -> QueueFamilyCheckpointPropertiesNV {
-        QueueFamilyCheckpointPropertiesNV {
-            s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             checkpoint_execution_stage_mask: PipelineStageFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for QueueFamilyCheckpointPropertiesNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV;
+}
 impl QueueFamilyCheckpointPropertiesNV {
     pub fn builder<'a>() -> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
         QueueFamilyCheckpointPropertiesNVBuilder {
-            inner: QueueFamilyCheckpointPropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29217,6 +32884,7 @@ impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointPropertiesNVBuilder<'a> {
     }
 }
 impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
+    #[inline]
     pub fn checkpoint_execution_stage_mask(
         mut self,
         checkpoint_execution_stage_mask: PipelineStageFlags,
@@ -29232,8 +32900,9 @@ impl<'a> QueueFamilyCheckpointPropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCheckpointDataNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointDataNV.html>"]
 pub struct CheckpointDataNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -29241,19 +32910,23 @@ pub struct CheckpointDataNV {
     pub p_checkpoint_marker: *mut c_void,
 }
 impl ::std::default::Default for CheckpointDataNV {
-    fn default() -> CheckpointDataNV {
-        CheckpointDataNV {
-            s_type: StructureType::CHECKPOINT_DATA_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             stage: PipelineStageFlags::default(),
             p_checkpoint_marker: ::std::ptr::null_mut(),
         }
     }
 }
+unsafe impl TaggedStructure for CheckpointDataNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::CHECKPOINT_DATA_NV;
+}
 impl CheckpointDataNV {
     pub fn builder<'a>() -> CheckpointDataNVBuilder<'a> {
         CheckpointDataNVBuilder {
-            inner: CheckpointDataNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29275,10 +32948,12 @@ impl<'a> ::std::ops::DerefMut for CheckpointDataNVBuilder<'a> {
     }
 }
 impl<'a> CheckpointDataNVBuilder<'a> {
+    #[inline]
     pub fn stage(mut self, stage: PipelineStageFlags) -> Self {
         self.inner.stage = stage;
         self
     }
+    #[inline]
     pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self {
         self.inner.p_checkpoint_marker = checkpoint_marker;
         self
@@ -29291,8 +32966,9 @@ impl<'a> CheckpointDataNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html>"]
 pub struct PhysicalDeviceDepthStencilResolveProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -29302,9 +32978,10 @@ pub struct PhysicalDeviceDepthStencilResolveProperties {
     pub independent_resolve: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties {
-    fn default() -> PhysicalDeviceDepthStencilResolveProperties {
-        PhysicalDeviceDepthStencilResolveProperties {
-            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             supported_depth_resolve_modes: ResolveModeFlags::default(),
             supported_stencil_resolve_modes: ResolveModeFlags::default(),
@@ -29313,10 +32990,14 @@ impl ::std::default::Default for PhysicalDeviceDepthStencilResolveProperties {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDepthStencilResolveProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
+}
 impl PhysicalDeviceDepthStencilResolveProperties {
     pub fn builder<'a>() -> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
         PhysicalDeviceDepthStencilResolvePropertiesBuilder {
-            inner: PhysicalDeviceDepthStencilResolveProperties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29343,6 +33024,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthStencilResolvePropertiesBui
     }
 }
 impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
+    #[inline]
     pub fn supported_depth_resolve_modes(
         mut self,
         supported_depth_resolve_modes: ResolveModeFlags,
@@ -29350,6 +33032,7 @@ impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
         self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
         self
     }
+    #[inline]
     pub fn supported_stencil_resolve_modes(
         mut self,
         supported_stencil_resolve_modes: ResolveModeFlags,
@@ -29357,10 +33040,12 @@ impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
         self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
         self
     }
+    #[inline]
     pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
         self.inner.independent_resolve_none = independent_resolve_none.into();
         self
     }
+    #[inline]
     pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
         self.inner.independent_resolve = independent_resolve.into();
         self
@@ -29373,8 +33058,9 @@ impl<'a> PhysicalDeviceDepthStencilResolvePropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassDescriptionDepthStencilResolve.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassDescriptionDepthStencilResolve.html>"]
 pub struct SubpassDescriptionDepthStencilResolve {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -29383,9 +33069,10 @@ pub struct SubpassDescriptionDepthStencilResolve {
     pub p_depth_stencil_resolve_attachment: *const AttachmentReference2,
 }
 impl ::std::default::Default for SubpassDescriptionDepthStencilResolve {
-    fn default() -> SubpassDescriptionDepthStencilResolve {
-        SubpassDescriptionDepthStencilResolve {
-            s_type: StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             depth_resolve_mode: ResolveModeFlags::default(),
             stencil_resolve_mode: ResolveModeFlags::default(),
@@ -29393,10 +33080,13 @@ impl ::std::default::Default for SubpassDescriptionDepthStencilResolve {
         }
     }
 }
+unsafe impl TaggedStructure for SubpassDescriptionDepthStencilResolve {
+    const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
+}
 impl SubpassDescriptionDepthStencilResolve {
     pub fn builder<'a>() -> SubpassDescriptionDepthStencilResolveBuilder<'a> {
         SubpassDescriptionDepthStencilResolveBuilder {
-            inner: SubpassDescriptionDepthStencilResolve::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29420,14 +33110,17 @@ impl<'a> ::std::ops::DerefMut for SubpassDescriptionDepthStencilResolveBuilder<'
     }
 }
 impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> {
+    #[inline]
     pub fn depth_resolve_mode(mut self, depth_resolve_mode: ResolveModeFlags) -> Self {
         self.inner.depth_resolve_mode = depth_resolve_mode;
         self
     }
+    #[inline]
     pub fn stencil_resolve_mode(mut self, stencil_resolve_mode: ResolveModeFlags) -> Self {
         self.inner.stencil_resolve_mode = stencil_resolve_mode;
         self
     }
+    #[inline]
     pub fn depth_stencil_resolve_attachment(
         mut self,
         depth_stencil_resolve_attachment: &'a AttachmentReference2,
@@ -29443,26 +33136,31 @@ impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewASTCDecodeModeEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewASTCDecodeModeEXT.html>"]
 pub struct ImageViewASTCDecodeModeEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub decode_mode: Format,
 }
 impl ::std::default::Default for ImageViewASTCDecodeModeEXT {
-    fn default() -> ImageViewASTCDecodeModeEXT {
-        ImageViewASTCDecodeModeEXT {
-            s_type: StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             decode_mode: Format::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageViewASTCDecodeModeEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
+}
 impl ImageViewASTCDecodeModeEXT {
     pub fn builder<'a>() -> ImageViewASTCDecodeModeEXTBuilder<'a> {
         ImageViewASTCDecodeModeEXTBuilder {
-            inner: ImageViewASTCDecodeModeEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29486,6 +33184,7 @@ impl<'a> ::std::ops::DerefMut for ImageViewASTCDecodeModeEXTBuilder<'a> {
     }
 }
 impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> {
+    #[inline]
     pub fn decode_mode(mut self, decode_mode: Format) -> Self {
         self.inner.decode_mode = decode_mode;
         self
@@ -29498,26 +33197,31 @@ impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html>"]
 pub struct PhysicalDeviceASTCDecodeFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub decode_mode_shared_exponent: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceASTCDecodeFeaturesEXT {
-    fn default() -> PhysicalDeviceASTCDecodeFeaturesEXT {
-        PhysicalDeviceASTCDecodeFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             decode_mode_shared_exponent: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceASTCDecodeFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT;
+}
 impl PhysicalDeviceASTCDecodeFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
         PhysicalDeviceASTCDecodeFeaturesEXTBuilder {
-            inner: PhysicalDeviceASTCDecodeFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29543,6 +33247,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a>
     }
 }
 impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn decode_mode_shared_exponent(mut self, decode_mode_shared_exponent: bool) -> Self {
         self.inner.decode_mode_shared_exponent = decode_mode_shared_exponent.into();
         self
@@ -29555,8 +33260,9 @@ impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html>"]
 pub struct PhysicalDeviceTransformFeedbackFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -29564,19 +33270,24 @@ pub struct PhysicalDeviceTransformFeedbackFeaturesEXT {
     pub geometry_streams: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceTransformFeedbackFeaturesEXT {
-    fn default() -> PhysicalDeviceTransformFeedbackFeaturesEXT {
-        PhysicalDeviceTransformFeedbackFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             transform_feedback: Bool32::default(),
             geometry_streams: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceTransformFeedbackFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
+}
 impl PhysicalDeviceTransformFeedbackFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
         PhysicalDeviceTransformFeedbackFeaturesEXTBuilder {
-            inner: PhysicalDeviceTransformFeedbackFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29605,10 +33316,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackFeaturesEXTBuil
     }
 }
 impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn transform_feedback(mut self, transform_feedback: bool) -> Self {
         self.inner.transform_feedback = transform_feedback.into();
         self
     }
+    #[inline]
     pub fn geometry_streams(mut self, geometry_streams: bool) -> Self {
         self.inner.geometry_streams = geometry_streams.into();
         self
@@ -29621,8 +33334,9 @@ impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html>"]
 pub struct PhysicalDeviceTransformFeedbackPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -29638,9 +33352,10 @@ pub struct PhysicalDeviceTransformFeedbackPropertiesEXT {
     pub transform_feedback_draw: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT {
-    fn default() -> PhysicalDeviceTransformFeedbackPropertiesEXT {
-        PhysicalDeviceTransformFeedbackPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_transform_feedback_streams: u32::default(),
             max_transform_feedback_buffers: u32::default(),
@@ -29655,10 +33370,14 @@ impl ::std::default::Default for PhysicalDeviceTransformFeedbackPropertiesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceTransformFeedbackPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT;
+}
 impl PhysicalDeviceTransformFeedbackPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
         PhysicalDeviceTransformFeedbackPropertiesEXTBuilder {
-            inner: PhysicalDeviceTransformFeedbackPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29685,14 +33404,17 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceTransformFeedbackPropertiesEXTBu
     }
 }
 impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn max_transform_feedback_streams(mut self, max_transform_feedback_streams: u32) -> Self {
         self.inner.max_transform_feedback_streams = max_transform_feedback_streams;
         self
     }
+    #[inline]
     pub fn max_transform_feedback_buffers(mut self, max_transform_feedback_buffers: u32) -> Self {
         self.inner.max_transform_feedback_buffers = max_transform_feedback_buffers;
         self
     }
+    #[inline]
     pub fn max_transform_feedback_buffer_size(
         mut self,
         max_transform_feedback_buffer_size: DeviceSize,
@@ -29700,6 +33422,7 @@ impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
         self.inner.max_transform_feedback_buffer_size = max_transform_feedback_buffer_size;
         self
     }
+    #[inline]
     pub fn max_transform_feedback_stream_data_size(
         mut self,
         max_transform_feedback_stream_data_size: u32,
@@ -29708,6 +33431,7 @@ impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
             max_transform_feedback_stream_data_size;
         self
     }
+    #[inline]
     pub fn max_transform_feedback_buffer_data_size(
         mut self,
         max_transform_feedback_buffer_data_size: u32,
@@ -29716,6 +33440,7 @@ impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
             max_transform_feedback_buffer_data_size;
         self
     }
+    #[inline]
     pub fn max_transform_feedback_buffer_data_stride(
         mut self,
         max_transform_feedback_buffer_data_stride: u32,
@@ -29724,10 +33449,12 @@ impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
             max_transform_feedback_buffer_data_stride;
         self
     }
+    #[inline]
     pub fn transform_feedback_queries(mut self, transform_feedback_queries: bool) -> Self {
         self.inner.transform_feedback_queries = transform_feedback_queries.into();
         self
     }
+    #[inline]
     pub fn transform_feedback_streams_lines_triangles(
         mut self,
         transform_feedback_streams_lines_triangles: bool,
@@ -29736,6 +33463,7 @@ impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
             transform_feedback_streams_lines_triangles.into();
         self
     }
+    #[inline]
     pub fn transform_feedback_rasterization_stream_select(
         mut self,
         transform_feedback_rasterization_stream_select: bool,
@@ -29744,6 +33472,7 @@ impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
             transform_feedback_rasterization_stream_select.into();
         self
     }
+    #[inline]
     pub fn transform_feedback_draw(mut self, transform_feedback_draw: bool) -> Self {
         self.inner.transform_feedback_draw = transform_feedback_draw.into();
         self
@@ -29756,8 +33485,9 @@ impl<'a> PhysicalDeviceTransformFeedbackPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html>"]
 pub struct PipelineRasterizationStateStreamCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -29765,19 +33495,24 @@ pub struct PipelineRasterizationStateStreamCreateInfoEXT {
     pub rasterization_stream: u32,
 }
 impl ::std::default::Default for PipelineRasterizationStateStreamCreateInfoEXT {
-    fn default() -> PipelineRasterizationStateStreamCreateInfoEXT {
-        PipelineRasterizationStateStreamCreateInfoEXT {
-            s_type: StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineRasterizationStateStreamCreateFlagsEXT::default(),
             rasterization_stream: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineRasterizationStateStreamCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT;
+}
 impl PipelineRasterizationStateStreamCreateInfoEXT {
     pub fn builder<'a>() -> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
         PipelineRasterizationStateStreamCreateInfoEXTBuilder {
-            inner: PipelineRasterizationStateStreamCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29807,10 +33542,12 @@ impl<'a> ::std::ops::DerefMut for PipelineRasterizationStateStreamCreateInfoEXTB
     }
 }
 impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineRasterizationStateStreamCreateFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn rasterization_stream(mut self, rasterization_stream: u32) -> Self {
         self.inner.rasterization_stream = rasterization_stream;
         self
@@ -29823,26 +33560,32 @@ impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html>"]
 pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub representative_fragment_test: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
-    fn default() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
-        PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             representative_fragment_test: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV;
+}
 impl PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
         PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder {
-            inner: PhysicalDeviceRepresentativeFragmentTestFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29874,6 +33617,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceRepresentativeFragmentTestFeatur
     }
 }
 impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn representative_fragment_test(mut self, representative_fragment_test: bool) -> Self {
         self.inner.representative_fragment_test = representative_fragment_test.into();
         self
@@ -29886,26 +33630,32 @@ impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html>"]
 pub struct PipelineRepresentativeFragmentTestStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub representative_fragment_test_enable: Bool32,
 }
 impl ::std::default::Default for PipelineRepresentativeFragmentTestStateCreateInfoNV {
-    fn default() -> PipelineRepresentativeFragmentTestStateCreateInfoNV {
-        PipelineRepresentativeFragmentTestStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             representative_fragment_test_enable: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineRepresentativeFragmentTestStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV;
+}
 impl PipelineRepresentativeFragmentTestStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
         PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder {
-            inner: PipelineRepresentativeFragmentTestStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29935,6 +33685,7 @@ impl<'a> ::std::ops::DerefMut for PipelineRepresentativeFragmentTestStateCreateI
     }
 }
 impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn representative_fragment_test_enable(
         mut self,
         representative_fragment_test_enable: bool,
@@ -29950,26 +33701,32 @@ impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html>"]
 pub struct PhysicalDeviceExclusiveScissorFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub exclusive_scissor: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceExclusiveScissorFeaturesNV {
-    fn default() -> PhysicalDeviceExclusiveScissorFeaturesNV {
-        PhysicalDeviceExclusiveScissorFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             exclusive_scissor: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceExclusiveScissorFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV;
+}
 impl PhysicalDeviceExclusiveScissorFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
         PhysicalDeviceExclusiveScissorFeaturesNVBuilder {
-            inner: PhysicalDeviceExclusiveScissorFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -29995,6 +33752,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceExclusiveScissorFeaturesNVBuilde
     }
 }
 impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn exclusive_scissor(mut self, exclusive_scissor: bool) -> Self {
         self.inner.exclusive_scissor = exclusive_scissor.into();
         self
@@ -30007,8 +33765,9 @@ impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html>"]
 pub struct PipelineViewportExclusiveScissorStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -30016,19 +33775,24 @@ pub struct PipelineViewportExclusiveScissorStateCreateInfoNV {
     pub p_exclusive_scissors: *const Rect2D,
 }
 impl ::std::default::Default for PipelineViewportExclusiveScissorStateCreateInfoNV {
-    fn default() -> PipelineViewportExclusiveScissorStateCreateInfoNV {
-        PipelineViewportExclusiveScissorStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             exclusive_scissor_count: u32::default(),
             p_exclusive_scissors: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineViewportExclusiveScissorStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV;
+}
 impl PipelineViewportExclusiveScissorStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
         PipelineViewportExclusiveScissorStateCreateInfoNVBuilder {
-            inner: PipelineViewportExclusiveScissorStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30058,6 +33822,7 @@ impl<'a> ::std::ops::DerefMut for PipelineViewportExclusiveScissorStateCreateInf
     }
 }
 impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn exclusive_scissors(mut self, exclusive_scissors: &'a [Rect2D]) -> Self {
         self.inner.exclusive_scissor_count = exclusive_scissors.len() as _;
         self.inner.p_exclusive_scissors = exclusive_scissors.as_ptr();
@@ -30071,26 +33836,32 @@ impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html>"]
 pub struct PhysicalDeviceCornerSampledImageFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub corner_sampled_image: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceCornerSampledImageFeaturesNV {
-    fn default() -> PhysicalDeviceCornerSampledImageFeaturesNV {
-        PhysicalDeviceCornerSampledImageFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             corner_sampled_image: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceCornerSampledImageFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV;
+}
 impl PhysicalDeviceCornerSampledImageFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
         PhysicalDeviceCornerSampledImageFeaturesNVBuilder {
-            inner: PhysicalDeviceCornerSampledImageFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30119,6 +33890,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceCornerSampledImageFeaturesNVBuil
     }
 }
 impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn corner_sampled_image(mut self, corner_sampled_image: bool) -> Self {
         self.inner.corner_sampled_image = corner_sampled_image.into();
         self
@@ -30131,8 +33903,9 @@ impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesNV.html>"]
 pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -30140,19 +33913,24 @@ pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNV {
     pub compute_derivative_group_linear: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceComputeShaderDerivativesFeaturesNV {
-    fn default() -> PhysicalDeviceComputeShaderDerivativesFeaturesNV {
-        PhysicalDeviceComputeShaderDerivativesFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             compute_derivative_group_quads: Bool32::default(),
             compute_derivative_group_linear: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceComputeShaderDerivativesFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV;
+}
 impl PhysicalDeviceComputeShaderDerivativesFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
         PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder {
-            inner: PhysicalDeviceComputeShaderDerivativesFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30184,10 +33962,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceComputeShaderDerivativesFeatures
     }
 }
 impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn compute_derivative_group_quads(mut self, compute_derivative_group_quads: bool) -> Self {
         self.inner.compute_derivative_group_quads = compute_derivative_group_quads.into();
         self
     }
+    #[inline]
     pub fn compute_derivative_group_linear(
         mut self,
         compute_derivative_group_linear: bool,
@@ -30203,89 +33983,32 @@ impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV.html>"]
-pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
-    pub s_type: StructureType,
-    pub p_next: *mut c_void,
-    pub fragment_shader_barycentric: Bool32,
-}
-impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
-    fn default() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
-        PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV,
-            p_next: ::std::ptr::null_mut(),
-            fragment_shader_barycentric: Bool32::default(),
-        }
-    }
-}
-impl PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
-    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
-        PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder {
-            inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV::default(),
-            marker: ::std::marker::PhantomData,
-        }
-    }
-}
-#[repr(transparent)]
-pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
-    inner: PhysicalDeviceFragmentShaderBarycentricFeaturesNV,
-    marker: ::std::marker::PhantomData<&'a ()>,
-}
-unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_>
-{
-}
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {}
-unsafe impl ExtendsDeviceCreateInfo
-    for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'_>
-{
-}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesNV {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
-    type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
-    pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self {
-        self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into();
-        self
-    }
-    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
-    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
-    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
-        self.inner
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html>"]
 pub struct PhysicalDeviceShaderImageFootprintFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub image_footprint: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderImageFootprintFeaturesNV {
-    fn default() -> PhysicalDeviceShaderImageFootprintFeaturesNV {
-        PhysicalDeviceShaderImageFootprintFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             image_footprint: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderImageFootprintFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV;
+}
 impl PhysicalDeviceShaderImageFootprintFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
         PhysicalDeviceShaderImageFootprintFeaturesNVBuilder {
-            inner: PhysicalDeviceShaderImageFootprintFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30314,6 +34037,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageFootprintFeaturesNVBu
     }
 }
 impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn image_footprint(mut self, image_footprint: bool) -> Self {
         self.inner.image_footprint = image_footprint.into();
         self
@@ -30326,26 +34050,32 @@ impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html>"]
 pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub dedicated_allocation_image_aliasing: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
-    fn default() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
-        PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             dedicated_allocation_image_aliasing: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV;
+}
 impl PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
         PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder {
-            inner: PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30382,6 +34112,7 @@ impl<'a> ::std::ops::DerefMut
     }
 }
 impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn dedicated_allocation_image_aliasing(
         mut self,
         dedicated_allocation_image_aliasing: bool,
@@ -30397,15 +34128,294 @@ impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShadingRatePaletteNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.html>"]
+pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub indirect_copy: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectFeaturesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            indirect_copy: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceCopyMemoryIndirectFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV;
+}
+impl PhysicalDeviceCopyMemoryIndirectFeaturesNV {
+    pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
+        PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
+    inner: PhysicalDeviceCopyMemoryIndirectFeaturesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCopyMemoryIndirectFeaturesNV {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
+    type Target = PhysicalDeviceCopyMemoryIndirectFeaturesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceCopyMemoryIndirectFeaturesNVBuilder<'a> {
+    #[inline]
+    pub fn indirect_copy(mut self, indirect_copy: bool) -> Self {
+        self.inner.indirect_copy = indirect_copy.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceCopyMemoryIndirectFeaturesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.html>"]
+pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub supported_queues: QueueFlags,
+}
+impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectPropertiesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            supported_queues: QueueFlags::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceCopyMemoryIndirectPropertiesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV;
+}
+impl PhysicalDeviceCopyMemoryIndirectPropertiesNV {
+    pub fn builder<'a>() -> PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
+        PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
+    inner: PhysicalDeviceCopyMemoryIndirectPropertiesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCopyMemoryIndirectPropertiesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
+    type Target = PhysicalDeviceCopyMemoryIndirectPropertiesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceCopyMemoryIndirectPropertiesNVBuilder<'a> {
+    #[inline]
+    pub fn supported_queues(mut self, supported_queues: QueueFlags) -> Self {
+        self.inner.supported_queues = supported_queues;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceCopyMemoryIndirectPropertiesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryDecompressionFeaturesNV.html>"]
+pub struct PhysicalDeviceMemoryDecompressionFeaturesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub memory_decompression: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceMemoryDecompressionFeaturesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            memory_decompression: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMemoryDecompressionFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV;
+}
+impl PhysicalDeviceMemoryDecompressionFeaturesNV {
+    pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
+        PhysicalDeviceMemoryDecompressionFeaturesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
+    inner: PhysicalDeviceMemoryDecompressionFeaturesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryDecompressionFeaturesNV {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
+    type Target = PhysicalDeviceMemoryDecompressionFeaturesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMemoryDecompressionFeaturesNVBuilder<'a> {
+    #[inline]
+    pub fn memory_decompression(mut self, memory_decompression: bool) -> Self {
+        self.inner.memory_decompression = memory_decompression.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMemoryDecompressionFeaturesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryDecompressionPropertiesNV.html>"]
+pub struct PhysicalDeviceMemoryDecompressionPropertiesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub decompression_methods: MemoryDecompressionMethodFlagsNV,
+    pub max_decompression_indirect_count: u64,
+}
+impl ::std::default::Default for PhysicalDeviceMemoryDecompressionPropertiesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            decompression_methods: MemoryDecompressionMethodFlagsNV::default(),
+            max_decompression_indirect_count: u64::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMemoryDecompressionPropertiesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV;
+}
+impl PhysicalDeviceMemoryDecompressionPropertiesNV {
+    pub fn builder<'a>() -> PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
+        PhysicalDeviceMemoryDecompressionPropertiesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
+    inner: PhysicalDeviceMemoryDecompressionPropertiesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMemoryDecompressionPropertiesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
+    type Target = PhysicalDeviceMemoryDecompressionPropertiesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMemoryDecompressionPropertiesNVBuilder<'a> {
+    #[inline]
+    pub fn decompression_methods(
+        mut self,
+        decompression_methods: MemoryDecompressionMethodFlagsNV,
+    ) -> Self {
+        self.inner.decompression_methods = decompression_methods;
+        self
+    }
+    #[inline]
+    pub fn max_decompression_indirect_count(
+        mut self,
+        max_decompression_indirect_count: u64,
+    ) -> Self {
+        self.inner.max_decompression_indirect_count = max_decompression_indirect_count;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMemoryDecompressionPropertiesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShadingRatePaletteNV.html>"]
 pub struct ShadingRatePaletteNV {
     pub shading_rate_palette_entry_count: u32,
     pub p_shading_rate_palette_entries: *const ShadingRatePaletteEntryNV,
 }
 impl ::std::default::Default for ShadingRatePaletteNV {
-    fn default() -> ShadingRatePaletteNV {
-        ShadingRatePaletteNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
             shading_rate_palette_entry_count: u32::default(),
             p_shading_rate_palette_entries: ::std::ptr::null(),
         }
@@ -30414,7 +34424,7 @@ impl ::std::default::Default for ShadingRatePaletteNV {
 impl ShadingRatePaletteNV {
     pub fn builder<'a>() -> ShadingRatePaletteNVBuilder<'a> {
         ShadingRatePaletteNVBuilder {
-            inner: ShadingRatePaletteNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30436,6 +34446,7 @@ impl<'a> ::std::ops::DerefMut for ShadingRatePaletteNVBuilder<'a> {
     }
 }
 impl<'a> ShadingRatePaletteNVBuilder<'a> {
+    #[inline]
     pub fn shading_rate_palette_entries(
         mut self,
         shading_rate_palette_entries: &'a [ShadingRatePaletteEntryNV],
@@ -30452,8 +34463,9 @@ impl<'a> ShadingRatePaletteNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html>"]
 pub struct PipelineViewportShadingRateImageStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -30462,9 +34474,10 @@ pub struct PipelineViewportShadingRateImageStateCreateInfoNV {
     pub p_shading_rate_palettes: *const ShadingRatePaletteNV,
 }
 impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfoNV {
-    fn default() -> PipelineViewportShadingRateImageStateCreateInfoNV {
-        PipelineViewportShadingRateImageStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             shading_rate_image_enable: Bool32::default(),
             viewport_count: u32::default(),
@@ -30472,10 +34485,14 @@ impl ::std::default::Default for PipelineViewportShadingRateImageStateCreateInfo
         }
     }
 }
+unsafe impl TaggedStructure for PipelineViewportShadingRateImageStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV;
+}
 impl PipelineViewportShadingRateImageStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
         PipelineViewportShadingRateImageStateCreateInfoNVBuilder {
-            inner: PipelineViewportShadingRateImageStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30505,10 +34522,12 @@ impl<'a> ::std::ops::DerefMut for PipelineViewportShadingRateImageStateCreateInf
     }
 }
 impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn shading_rate_image_enable(mut self, shading_rate_image_enable: bool) -> Self {
         self.inner.shading_rate_image_enable = shading_rate_image_enable.into();
         self
     }
+    #[inline]
     pub fn shading_rate_palettes(
         mut self,
         shading_rate_palettes: &'a [ShadingRatePaletteNV],
@@ -30525,8 +34544,9 @@ impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html>"]
 pub struct PhysicalDeviceShadingRateImageFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -30534,19 +34554,24 @@ pub struct PhysicalDeviceShadingRateImageFeaturesNV {
     pub shading_rate_coarse_sample_order: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShadingRateImageFeaturesNV {
-    fn default() -> PhysicalDeviceShadingRateImageFeaturesNV {
-        PhysicalDeviceShadingRateImageFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shading_rate_image: Bool32::default(),
             shading_rate_coarse_sample_order: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShadingRateImageFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV;
+}
 impl PhysicalDeviceShadingRateImageFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
         PhysicalDeviceShadingRateImageFeaturesNVBuilder {
-            inner: PhysicalDeviceShadingRateImageFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30572,10 +34597,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImageFeaturesNVBuilde
     }
 }
 impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn shading_rate_image(mut self, shading_rate_image: bool) -> Self {
         self.inner.shading_rate_image = shading_rate_image.into();
         self
     }
+    #[inline]
     pub fn shading_rate_coarse_sample_order(
         mut self,
         shading_rate_coarse_sample_order: bool,
@@ -30591,8 +34618,9 @@ impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html>"]
 pub struct PhysicalDeviceShadingRateImagePropertiesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -30601,9 +34629,10 @@ pub struct PhysicalDeviceShadingRateImagePropertiesNV {
     pub shading_rate_max_coarse_samples: u32,
 }
 impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV {
-    fn default() -> PhysicalDeviceShadingRateImagePropertiesNV {
-        PhysicalDeviceShadingRateImagePropertiesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shading_rate_texel_size: Extent2D::default(),
             shading_rate_palette_size: u32::default(),
@@ -30611,10 +34640,14 @@ impl ::std::default::Default for PhysicalDeviceShadingRateImagePropertiesNV {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShadingRateImagePropertiesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV;
+}
 impl PhysicalDeviceShadingRateImagePropertiesNV {
     pub fn builder<'a>() -> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
         PhysicalDeviceShadingRateImagePropertiesNVBuilder {
-            inner: PhysicalDeviceShadingRateImagePropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30641,14 +34674,17 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShadingRateImagePropertiesNVBuil
     }
 }
 impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
+    #[inline]
     pub fn shading_rate_texel_size(mut self, shading_rate_texel_size: Extent2D) -> Self {
         self.inner.shading_rate_texel_size = shading_rate_texel_size;
         self
     }
+    #[inline]
     pub fn shading_rate_palette_size(mut self, shading_rate_palette_size: u32) -> Self {
         self.inner.shading_rate_palette_size = shading_rate_palette_size;
         self
     }
+    #[inline]
     pub fn shading_rate_max_coarse_samples(mut self, shading_rate_max_coarse_samples: u32) -> Self {
         self.inner.shading_rate_max_coarse_samples = shading_rate_max_coarse_samples;
         self
@@ -30661,26 +34697,32 @@ impl<'a> PhysicalDeviceShadingRateImagePropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html>"]
 pub struct PhysicalDeviceInvocationMaskFeaturesHUAWEI {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub invocation_mask: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceInvocationMaskFeaturesHUAWEI {
-    fn default() -> PhysicalDeviceInvocationMaskFeaturesHUAWEI {
-        PhysicalDeviceInvocationMaskFeaturesHUAWEI {
-            s_type: StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             invocation_mask: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceInvocationMaskFeaturesHUAWEI {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI;
+}
 impl PhysicalDeviceInvocationMaskFeaturesHUAWEI {
     pub fn builder<'a>() -> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
         PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder {
-            inner: PhysicalDeviceInvocationMaskFeaturesHUAWEI::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30709,6 +34751,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceInvocationMaskFeaturesHUAWEIBuil
     }
 }
 impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
+    #[inline]
     pub fn invocation_mask(mut self, invocation_mask: bool) -> Self {
         self.inner.invocation_mask = invocation_mask.into();
         self
@@ -30721,8 +34764,9 @@ impl<'a> PhysicalDeviceInvocationMaskFeaturesHUAWEIBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoarseSampleLocationNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleLocationNV.html>"]
 pub struct CoarseSampleLocationNV {
     pub pixel_x: u32,
     pub pixel_y: u32,
@@ -30731,7 +34775,7 @@ pub struct CoarseSampleLocationNV {
 impl CoarseSampleLocationNV {
     pub fn builder<'a>() -> CoarseSampleLocationNVBuilder<'a> {
         CoarseSampleLocationNVBuilder {
-            inner: CoarseSampleLocationNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30753,14 +34797,17 @@ impl<'a> ::std::ops::DerefMut for CoarseSampleLocationNVBuilder<'a> {
     }
 }
 impl<'a> CoarseSampleLocationNVBuilder<'a> {
+    #[inline]
     pub fn pixel_x(mut self, pixel_x: u32) -> Self {
         self.inner.pixel_x = pixel_x;
         self
     }
+    #[inline]
     pub fn pixel_y(mut self, pixel_y: u32) -> Self {
         self.inner.pixel_y = pixel_y;
         self
     }
+    #[inline]
     pub fn sample(mut self, sample: u32) -> Self {
         self.inner.sample = sample;
         self
@@ -30773,8 +34820,9 @@ impl<'a> CoarseSampleLocationNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoarseSampleOrderCustomNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleOrderCustomNV.html>"]
 pub struct CoarseSampleOrderCustomNV {
     pub shading_rate: ShadingRatePaletteEntryNV,
     pub sample_count: u32,
@@ -30782,8 +34830,9 @@ pub struct CoarseSampleOrderCustomNV {
     pub p_sample_locations: *const CoarseSampleLocationNV,
 }
 impl ::std::default::Default for CoarseSampleOrderCustomNV {
-    fn default() -> CoarseSampleOrderCustomNV {
-        CoarseSampleOrderCustomNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
             shading_rate: ShadingRatePaletteEntryNV::default(),
             sample_count: u32::default(),
             sample_location_count: u32::default(),
@@ -30794,7 +34843,7 @@ impl ::std::default::Default for CoarseSampleOrderCustomNV {
 impl CoarseSampleOrderCustomNV {
     pub fn builder<'a>() -> CoarseSampleOrderCustomNVBuilder<'a> {
         CoarseSampleOrderCustomNVBuilder {
-            inner: CoarseSampleOrderCustomNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30816,14 +34865,17 @@ impl<'a> ::std::ops::DerefMut for CoarseSampleOrderCustomNVBuilder<'a> {
     }
 }
 impl<'a> CoarseSampleOrderCustomNVBuilder<'a> {
+    #[inline]
     pub fn shading_rate(mut self, shading_rate: ShadingRatePaletteEntryNV) -> Self {
         self.inner.shading_rate = shading_rate;
         self
     }
+    #[inline]
     pub fn sample_count(mut self, sample_count: u32) -> Self {
         self.inner.sample_count = sample_count;
         self
     }
+    #[inline]
     pub fn sample_locations(mut self, sample_locations: &'a [CoarseSampleLocationNV]) -> Self {
         self.inner.sample_location_count = sample_locations.len() as _;
         self.inner.p_sample_locations = sample_locations.as_ptr();
@@ -30837,8 +34889,9 @@ impl<'a> CoarseSampleOrderCustomNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html>"]
 pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -30847,9 +34900,10 @@ pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNV {
     pub p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
 }
 impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInfoNV {
-    fn default() -> PipelineViewportCoarseSampleOrderStateCreateInfoNV {
-        PipelineViewportCoarseSampleOrderStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             sample_order_type: CoarseSampleOrderTypeNV::default(),
             custom_sample_order_count: u32::default(),
@@ -30857,10 +34911,14 @@ impl ::std::default::Default for PipelineViewportCoarseSampleOrderStateCreateInf
         }
     }
 }
+unsafe impl TaggedStructure for PipelineViewportCoarseSampleOrderStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV;
+}
 impl PipelineViewportCoarseSampleOrderStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
         PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder {
-            inner: PipelineViewportCoarseSampleOrderStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30890,10 +34948,12 @@ impl<'a> ::std::ops::DerefMut for PipelineViewportCoarseSampleOrderStateCreateIn
     }
 }
 impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn sample_order_type(mut self, sample_order_type: CoarseSampleOrderTypeNV) -> Self {
         self.inner.sample_order_type = sample_order_type;
         self
     }
+    #[inline]
     pub fn custom_sample_orders(
         mut self,
         custom_sample_orders: &'a [CoarseSampleOrderCustomNV],
@@ -30910,8 +34970,9 @@ impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html>"]
 pub struct PhysicalDeviceMeshShaderFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -30919,19 +34980,23 @@ pub struct PhysicalDeviceMeshShaderFeaturesNV {
     pub mesh_shader: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesNV {
-    fn default() -> PhysicalDeviceMeshShaderFeaturesNV {
-        PhysicalDeviceMeshShaderFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             task_shader: Bool32::default(),
             mesh_shader: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMeshShaderFeaturesNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV;
+}
 impl PhysicalDeviceMeshShaderFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
         PhysicalDeviceMeshShaderFeaturesNVBuilder {
-            inner: PhysicalDeviceMeshShaderFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -30957,10 +35022,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a>
     }
 }
 impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn task_shader(mut self, task_shader: bool) -> Self {
         self.inner.task_shader = task_shader.into();
         self
     }
+    #[inline]
     pub fn mesh_shader(mut self, mesh_shader: bool) -> Self {
         self.inner.mesh_shader = mesh_shader.into();
         self
@@ -30973,8 +35040,9 @@ impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html>"]
 pub struct PhysicalDeviceMeshShaderPropertiesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -30993,9 +35061,10 @@ pub struct PhysicalDeviceMeshShaderPropertiesNV {
     pub mesh_output_per_primitive_granularity: u32,
 }
 impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV {
-    fn default() -> PhysicalDeviceMeshShaderPropertiesNV {
-        PhysicalDeviceMeshShaderPropertiesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_draw_mesh_tasks_count: u32::default(),
             max_task_work_group_invocations: u32::default(),
@@ -31013,10 +35082,13 @@ impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesNV {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMeshShaderPropertiesNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV;
+}
 impl PhysicalDeviceMeshShaderPropertiesNV {
     pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
         PhysicalDeviceMeshShaderPropertiesNVBuilder {
-            inner: PhysicalDeviceMeshShaderPropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31040,50 +35112,62 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesNVBuilder<'a
     }
 }
 impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
+    #[inline]
     pub fn max_draw_mesh_tasks_count(mut self, max_draw_mesh_tasks_count: u32) -> Self {
         self.inner.max_draw_mesh_tasks_count = max_draw_mesh_tasks_count;
         self
     }
+    #[inline]
     pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self {
         self.inner.max_task_work_group_invocations = max_task_work_group_invocations;
         self
     }
+    #[inline]
     pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self {
         self.inner.max_task_work_group_size = max_task_work_group_size;
         self
     }
+    #[inline]
     pub fn max_task_total_memory_size(mut self, max_task_total_memory_size: u32) -> Self {
         self.inner.max_task_total_memory_size = max_task_total_memory_size;
         self
     }
+    #[inline]
     pub fn max_task_output_count(mut self, max_task_output_count: u32) -> Self {
         self.inner.max_task_output_count = max_task_output_count;
         self
     }
+    #[inline]
     pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self {
         self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations;
         self
     }
+    #[inline]
     pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self {
         self.inner.max_mesh_work_group_size = max_mesh_work_group_size;
         self
     }
+    #[inline]
     pub fn max_mesh_total_memory_size(mut self, max_mesh_total_memory_size: u32) -> Self {
         self.inner.max_mesh_total_memory_size = max_mesh_total_memory_size;
         self
     }
+    #[inline]
     pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self {
         self.inner.max_mesh_output_vertices = max_mesh_output_vertices;
         self
     }
+    #[inline]
     pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self {
         self.inner.max_mesh_output_primitives = max_mesh_output_primitives;
         self
     }
+    #[inline]
     pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self {
         self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count;
         self
     }
+    #[inline]
     pub fn mesh_output_per_vertex_granularity(
         mut self,
         mesh_output_per_vertex_granularity: u32,
@@ -31091,6 +35175,7 @@ impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
         self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity;
         self
     }
+    #[inline]
     pub fn mesh_output_per_primitive_granularity(
         mut self,
         mesh_output_per_primitive_granularity: u32,
@@ -31106,8 +35191,9 @@ impl<'a> PhysicalDeviceMeshShaderPropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrawMeshTasksIndirectCommandNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawMeshTasksIndirectCommandNV.html>"]
 pub struct DrawMeshTasksIndirectCommandNV {
     pub task_count: u32,
     pub first_task: u32,
@@ -31115,7 +35201,7 @@ pub struct DrawMeshTasksIndirectCommandNV {
 impl DrawMeshTasksIndirectCommandNV {
     pub fn builder<'a>() -> DrawMeshTasksIndirectCommandNVBuilder<'a> {
         DrawMeshTasksIndirectCommandNVBuilder {
-            inner: DrawMeshTasksIndirectCommandNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31137,10 +35223,12 @@ impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandNVBuilder<'a> {
     }
 }
 impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> {
+    #[inline]
     pub fn task_count(mut self, task_count: u32) -> Self {
         self.inner.task_count = task_count;
         self
     }
+    #[inline]
     pub fn first_task(mut self, first_task: u32) -> Self {
         self.inner.first_task = first_task;
         self
@@ -31153,8 +35241,447 @@ impl<'a> DrawMeshTasksIndirectCommandNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingShaderGroupCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderFeaturesEXT.html>"]
+pub struct PhysicalDeviceMeshShaderFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub task_shader: Bool32,
+    pub mesh_shader: Bool32,
+    pub multiview_mesh_shader: Bool32,
+    pub primitive_fragment_shading_rate_mesh_shader: Bool32,
+    pub mesh_shader_queries: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceMeshShaderFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            task_shader: Bool32::default(),
+            mesh_shader: Bool32::default(),
+            multiview_mesh_shader: Bool32::default(),
+            primitive_fragment_shading_rate_mesh_shader: Bool32::default(),
+            mesh_shader_queries: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMeshShaderFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT;
+}
+impl PhysicalDeviceMeshShaderFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
+        PhysicalDeviceMeshShaderFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceMeshShaderFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMeshShaderFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMeshShaderFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceMeshShaderFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMeshShaderFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn task_shader(mut self, task_shader: bool) -> Self {
+        self.inner.task_shader = task_shader.into();
+        self
+    }
+    #[inline]
+    pub fn mesh_shader(mut self, mesh_shader: bool) -> Self {
+        self.inner.mesh_shader = mesh_shader.into();
+        self
+    }
+    #[inline]
+    pub fn multiview_mesh_shader(mut self, multiview_mesh_shader: bool) -> Self {
+        self.inner.multiview_mesh_shader = multiview_mesh_shader.into();
+        self
+    }
+    #[inline]
+    pub fn primitive_fragment_shading_rate_mesh_shader(
+        mut self,
+        primitive_fragment_shading_rate_mesh_shader: bool,
+    ) -> Self {
+        self.inner.primitive_fragment_shading_rate_mesh_shader =
+            primitive_fragment_shading_rate_mesh_shader.into();
+        self
+    }
+    #[inline]
+    pub fn mesh_shader_queries(mut self, mesh_shader_queries: bool) -> Self {
+        self.inner.mesh_shader_queries = mesh_shader_queries.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMeshShaderFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMeshShaderPropertiesEXT.html>"]
+pub struct PhysicalDeviceMeshShaderPropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub max_task_work_group_total_count: u32,
+    pub max_task_work_group_count: [u32; 3],
+    pub max_task_work_group_invocations: u32,
+    pub max_task_work_group_size: [u32; 3],
+    pub max_task_payload_size: u32,
+    pub max_task_shared_memory_size: u32,
+    pub max_task_payload_and_shared_memory_size: u32,
+    pub max_mesh_work_group_total_count: u32,
+    pub max_mesh_work_group_count: [u32; 3],
+    pub max_mesh_work_group_invocations: u32,
+    pub max_mesh_work_group_size: [u32; 3],
+    pub max_mesh_shared_memory_size: u32,
+    pub max_mesh_payload_and_shared_memory_size: u32,
+    pub max_mesh_output_memory_size: u32,
+    pub max_mesh_payload_and_output_memory_size: u32,
+    pub max_mesh_output_components: u32,
+    pub max_mesh_output_vertices: u32,
+    pub max_mesh_output_primitives: u32,
+    pub max_mesh_output_layers: u32,
+    pub max_mesh_multiview_view_count: u32,
+    pub mesh_output_per_vertex_granularity: u32,
+    pub mesh_output_per_primitive_granularity: u32,
+    pub max_preferred_task_work_group_invocations: u32,
+    pub max_preferred_mesh_work_group_invocations: u32,
+    pub prefers_local_invocation_vertex_output: Bool32,
+    pub prefers_local_invocation_primitive_output: Bool32,
+    pub prefers_compact_vertex_output: Bool32,
+    pub prefers_compact_primitive_output: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceMeshShaderPropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            max_task_work_group_total_count: u32::default(),
+            max_task_work_group_count: unsafe { ::std::mem::zeroed() },
+            max_task_work_group_invocations: u32::default(),
+            max_task_work_group_size: unsafe { ::std::mem::zeroed() },
+            max_task_payload_size: u32::default(),
+            max_task_shared_memory_size: u32::default(),
+            max_task_payload_and_shared_memory_size: u32::default(),
+            max_mesh_work_group_total_count: u32::default(),
+            max_mesh_work_group_count: unsafe { ::std::mem::zeroed() },
+            max_mesh_work_group_invocations: u32::default(),
+            max_mesh_work_group_size: unsafe { ::std::mem::zeroed() },
+            max_mesh_shared_memory_size: u32::default(),
+            max_mesh_payload_and_shared_memory_size: u32::default(),
+            max_mesh_output_memory_size: u32::default(),
+            max_mesh_payload_and_output_memory_size: u32::default(),
+            max_mesh_output_components: u32::default(),
+            max_mesh_output_vertices: u32::default(),
+            max_mesh_output_primitives: u32::default(),
+            max_mesh_output_layers: u32::default(),
+            max_mesh_multiview_view_count: u32::default(),
+            mesh_output_per_vertex_granularity: u32::default(),
+            mesh_output_per_primitive_granularity: u32::default(),
+            max_preferred_task_work_group_invocations: u32::default(),
+            max_preferred_mesh_work_group_invocations: u32::default(),
+            prefers_local_invocation_vertex_output: Bool32::default(),
+            prefers_local_invocation_primitive_output: Bool32::default(),
+            prefers_compact_vertex_output: Bool32::default(),
+            prefers_compact_primitive_output: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMeshShaderPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT;
+}
+impl PhysicalDeviceMeshShaderPropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
+        PhysicalDeviceMeshShaderPropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
+    inner: PhysicalDeviceMeshShaderPropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMeshShaderPropertiesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
+    type Target = PhysicalDeviceMeshShaderPropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMeshShaderPropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn max_task_work_group_total_count(mut self, max_task_work_group_total_count: u32) -> Self {
+        self.inner.max_task_work_group_total_count = max_task_work_group_total_count;
+        self
+    }
+    #[inline]
+    pub fn max_task_work_group_count(mut self, max_task_work_group_count: [u32; 3]) -> Self {
+        self.inner.max_task_work_group_count = max_task_work_group_count;
+        self
+    }
+    #[inline]
+    pub fn max_task_work_group_invocations(mut self, max_task_work_group_invocations: u32) -> Self {
+        self.inner.max_task_work_group_invocations = max_task_work_group_invocations;
+        self
+    }
+    #[inline]
+    pub fn max_task_work_group_size(mut self, max_task_work_group_size: [u32; 3]) -> Self {
+        self.inner.max_task_work_group_size = max_task_work_group_size;
+        self
+    }
+    #[inline]
+    pub fn max_task_payload_size(mut self, max_task_payload_size: u32) -> Self {
+        self.inner.max_task_payload_size = max_task_payload_size;
+        self
+    }
+    #[inline]
+    pub fn max_task_shared_memory_size(mut self, max_task_shared_memory_size: u32) -> Self {
+        self.inner.max_task_shared_memory_size = max_task_shared_memory_size;
+        self
+    }
+    #[inline]
+    pub fn max_task_payload_and_shared_memory_size(
+        mut self,
+        max_task_payload_and_shared_memory_size: u32,
+    ) -> Self {
+        self.inner.max_task_payload_and_shared_memory_size =
+            max_task_payload_and_shared_memory_size;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_work_group_total_count(mut self, max_mesh_work_group_total_count: u32) -> Self {
+        self.inner.max_mesh_work_group_total_count = max_mesh_work_group_total_count;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_work_group_count(mut self, max_mesh_work_group_count: [u32; 3]) -> Self {
+        self.inner.max_mesh_work_group_count = max_mesh_work_group_count;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_work_group_invocations(mut self, max_mesh_work_group_invocations: u32) -> Self {
+        self.inner.max_mesh_work_group_invocations = max_mesh_work_group_invocations;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_work_group_size(mut self, max_mesh_work_group_size: [u32; 3]) -> Self {
+        self.inner.max_mesh_work_group_size = max_mesh_work_group_size;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_shared_memory_size(mut self, max_mesh_shared_memory_size: u32) -> Self {
+        self.inner.max_mesh_shared_memory_size = max_mesh_shared_memory_size;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_payload_and_shared_memory_size(
+        mut self,
+        max_mesh_payload_and_shared_memory_size: u32,
+    ) -> Self {
+        self.inner.max_mesh_payload_and_shared_memory_size =
+            max_mesh_payload_and_shared_memory_size;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_output_memory_size(mut self, max_mesh_output_memory_size: u32) -> Self {
+        self.inner.max_mesh_output_memory_size = max_mesh_output_memory_size;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_payload_and_output_memory_size(
+        mut self,
+        max_mesh_payload_and_output_memory_size: u32,
+    ) -> Self {
+        self.inner.max_mesh_payload_and_output_memory_size =
+            max_mesh_payload_and_output_memory_size;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_output_components(mut self, max_mesh_output_components: u32) -> Self {
+        self.inner.max_mesh_output_components = max_mesh_output_components;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_output_vertices(mut self, max_mesh_output_vertices: u32) -> Self {
+        self.inner.max_mesh_output_vertices = max_mesh_output_vertices;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_output_primitives(mut self, max_mesh_output_primitives: u32) -> Self {
+        self.inner.max_mesh_output_primitives = max_mesh_output_primitives;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_output_layers(mut self, max_mesh_output_layers: u32) -> Self {
+        self.inner.max_mesh_output_layers = max_mesh_output_layers;
+        self
+    }
+    #[inline]
+    pub fn max_mesh_multiview_view_count(mut self, max_mesh_multiview_view_count: u32) -> Self {
+        self.inner.max_mesh_multiview_view_count = max_mesh_multiview_view_count;
+        self
+    }
+    #[inline]
+    pub fn mesh_output_per_vertex_granularity(
+        mut self,
+        mesh_output_per_vertex_granularity: u32,
+    ) -> Self {
+        self.inner.mesh_output_per_vertex_granularity = mesh_output_per_vertex_granularity;
+        self
+    }
+    #[inline]
+    pub fn mesh_output_per_primitive_granularity(
+        mut self,
+        mesh_output_per_primitive_granularity: u32,
+    ) -> Self {
+        self.inner.mesh_output_per_primitive_granularity = mesh_output_per_primitive_granularity;
+        self
+    }
+    #[inline]
+    pub fn max_preferred_task_work_group_invocations(
+        mut self,
+        max_preferred_task_work_group_invocations: u32,
+    ) -> Self {
+        self.inner.max_preferred_task_work_group_invocations =
+            max_preferred_task_work_group_invocations;
+        self
+    }
+    #[inline]
+    pub fn max_preferred_mesh_work_group_invocations(
+        mut self,
+        max_preferred_mesh_work_group_invocations: u32,
+    ) -> Self {
+        self.inner.max_preferred_mesh_work_group_invocations =
+            max_preferred_mesh_work_group_invocations;
+        self
+    }
+    #[inline]
+    pub fn prefers_local_invocation_vertex_output(
+        mut self,
+        prefers_local_invocation_vertex_output: bool,
+    ) -> Self {
+        self.inner.prefers_local_invocation_vertex_output =
+            prefers_local_invocation_vertex_output.into();
+        self
+    }
+    #[inline]
+    pub fn prefers_local_invocation_primitive_output(
+        mut self,
+        prefers_local_invocation_primitive_output: bool,
+    ) -> Self {
+        self.inner.prefers_local_invocation_primitive_output =
+            prefers_local_invocation_primitive_output.into();
+        self
+    }
+    #[inline]
+    pub fn prefers_compact_vertex_output(mut self, prefers_compact_vertex_output: bool) -> Self {
+        self.inner.prefers_compact_vertex_output = prefers_compact_vertex_output.into();
+        self
+    }
+    #[inline]
+    pub fn prefers_compact_primitive_output(
+        mut self,
+        prefers_compact_primitive_output: bool,
+    ) -> Self {
+        self.inner.prefers_compact_primitive_output = prefers_compact_primitive_output.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMeshShaderPropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrawMeshTasksIndirectCommandEXT.html>"]
+pub struct DrawMeshTasksIndirectCommandEXT {
+    pub group_count_x: u32,
+    pub group_count_y: u32,
+    pub group_count_z: u32,
+}
+impl DrawMeshTasksIndirectCommandEXT {
+    pub fn builder<'a>() -> DrawMeshTasksIndirectCommandEXTBuilder<'a> {
+        DrawMeshTasksIndirectCommandEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DrawMeshTasksIndirectCommandEXTBuilder<'a> {
+    inner: DrawMeshTasksIndirectCommandEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DrawMeshTasksIndirectCommandEXTBuilder<'a> {
+    type Target = DrawMeshTasksIndirectCommandEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DrawMeshTasksIndirectCommandEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DrawMeshTasksIndirectCommandEXTBuilder<'a> {
+    #[inline]
+    pub fn group_count_x(mut self, group_count_x: u32) -> Self {
+        self.inner.group_count_x = group_count_x;
+        self
+    }
+    #[inline]
+    pub fn group_count_y(mut self, group_count_y: u32) -> Self {
+        self.inner.group_count_y = group_count_y;
+        self
+    }
+    #[inline]
+    pub fn group_count_z(mut self, group_count_z: u32) -> Self {
+        self.inner.group_count_z = group_count_z;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DrawMeshTasksIndirectCommandEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoNV.html>"]
 pub struct RayTracingShaderGroupCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -31165,9 +35692,10 @@ pub struct RayTracingShaderGroupCreateInfoNV {
     pub intersection_shader: u32,
 }
 impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV {
-    fn default() -> RayTracingShaderGroupCreateInfoNV {
-        RayTracingShaderGroupCreateInfoNV {
-            s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             ty: RayTracingShaderGroupTypeKHR::default(),
             general_shader: u32::default(),
@@ -31177,10 +35705,13 @@ impl ::std::default::Default for RayTracingShaderGroupCreateInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for RayTracingShaderGroupCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV;
+}
 impl RayTracingShaderGroupCreateInfoNV {
     pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
         RayTracingShaderGroupCreateInfoNVBuilder {
-            inner: RayTracingShaderGroupCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31202,22 +35733,27 @@ impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
     }
 }
 impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn general_shader(mut self, general_shader: u32) -> Self {
         self.inner.general_shader = general_shader;
         self
     }
+    #[inline]
     pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
         self.inner.closest_hit_shader = closest_hit_shader;
         self
     }
+    #[inline]
     pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
         self.inner.any_hit_shader = any_hit_shader;
         self
     }
+    #[inline]
     pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
         self.inner.intersection_shader = intersection_shader;
         self
@@ -31230,8 +35766,9 @@ impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingShaderGroupCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupCreateInfoKHR.html>"]
 pub struct RayTracingShaderGroupCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -31243,9 +35780,10 @@ pub struct RayTracingShaderGroupCreateInfoKHR {
     pub p_shader_group_capture_replay_handle: *const c_void,
 }
 impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR {
-    fn default() -> RayTracingShaderGroupCreateInfoKHR {
-        RayTracingShaderGroupCreateInfoKHR {
-            s_type: StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             ty: RayTracingShaderGroupTypeKHR::default(),
             general_shader: u32::default(),
@@ -31256,10 +35794,13 @@ impl ::std::default::Default for RayTracingShaderGroupCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for RayTracingShaderGroupCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
+}
 impl RayTracingShaderGroupCreateInfoKHR {
     pub fn builder<'a>() -> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
         RayTracingShaderGroupCreateInfoKHRBuilder {
-            inner: RayTracingShaderGroupCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31281,26 +35822,32 @@ impl<'a> ::std::ops::DerefMut for RayTracingShaderGroupCreateInfoKHRBuilder<'a>
     }
 }
 impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: RayTracingShaderGroupTypeKHR) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn general_shader(mut self, general_shader: u32) -> Self {
         self.inner.general_shader = general_shader;
         self
     }
+    #[inline]
     pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
         self.inner.closest_hit_shader = closest_hit_shader;
         self
     }
+    #[inline]
     pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
         self.inner.any_hit_shader = any_hit_shader;
         self
     }
+    #[inline]
     pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
         self.inner.intersection_shader = intersection_shader;
         self
     }
+    #[inline]
     pub fn shader_group_capture_replay_handle(
         mut self,
         shader_group_capture_replay_handle: *const c_void,
@@ -31316,8 +35863,9 @@ impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingPipelineCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoNV.html>"]
 pub struct RayTracingPipelineCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -31332,9 +35880,10 @@ pub struct RayTracingPipelineCreateInfoNV {
     pub base_pipeline_index: i32,
 }
 impl ::std::default::Default for RayTracingPipelineCreateInfoNV {
-    fn default() -> RayTracingPipelineCreateInfoNV {
-        RayTracingPipelineCreateInfoNV {
-            s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineCreateFlags::default(),
             stage_count: u32::default(),
@@ -31348,10 +35897,13 @@ impl ::std::default::Default for RayTracingPipelineCreateInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for RayTracingPipelineCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_NV;
+}
 impl RayTracingPipelineCreateInfoNV {
     pub fn builder<'a>() -> RayTracingPipelineCreateInfoNVBuilder<'a> {
         RayTracingPipelineCreateInfoNVBuilder {
-            inner: RayTracingPipelineCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31374,32 +35926,39 @@ impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoNVBuilder<'a> {
     }
 }
 impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
         self.inner.stage_count = stages.len() as _;
         self.inner.p_stages = stages.as_ptr();
         self
     }
+    #[inline]
     pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoNV]) -> Self {
         self.inner.group_count = groups.len() as _;
         self.inner.p_groups = groups.as_ptr();
         self
     }
+    #[inline]
     pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
         self.inner.max_recursion_depth = max_recursion_depth;
         self
     }
+    #[inline]
     pub fn layout(mut self, layout: PipelineLayout) -> Self {
         self.inner.layout = layout;
         self
     }
+    #[inline]
     pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
         self.inner.base_pipeline_handle = base_pipeline_handle;
         self
     }
+    #[inline]
     pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
         self.inner.base_pipeline_index = base_pipeline_index;
         self
@@ -31411,10 +35970,10 @@ impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoNV>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -31426,8 +35985,9 @@ impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingPipelineCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineCreateInfoKHR.html>"]
 pub struct RayTracingPipelineCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -31445,9 +36005,10 @@ pub struct RayTracingPipelineCreateInfoKHR {
     pub base_pipeline_index: i32,
 }
 impl ::std::default::Default for RayTracingPipelineCreateInfoKHR {
-    fn default() -> RayTracingPipelineCreateInfoKHR {
-        RayTracingPipelineCreateInfoKHR {
-            s_type: StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineCreateFlags::default(),
             stage_count: u32::default(),
@@ -31464,10 +36025,13 @@ impl ::std::default::Default for RayTracingPipelineCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for RayTracingPipelineCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::RAY_TRACING_PIPELINE_CREATE_INFO_KHR;
+}
 impl RayTracingPipelineCreateInfoKHR {
     pub fn builder<'a>() -> RayTracingPipelineCreateInfoKHRBuilder<'a> {
         RayTracingPipelineCreateInfoKHRBuilder {
-            inner: RayTracingPipelineCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31490,20 +36054,24 @@ impl<'a> ::std::ops::DerefMut for RayTracingPipelineCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn stages(mut self, stages: &'a [PipelineShaderStageCreateInfo]) -> Self {
         self.inner.stage_count = stages.len() as _;
         self.inner.p_stages = stages.as_ptr();
         self
     }
+    #[inline]
     pub fn groups(mut self, groups: &'a [RayTracingShaderGroupCreateInfoKHR]) -> Self {
         self.inner.group_count = groups.len() as _;
         self.inner.p_groups = groups.as_ptr();
         self
     }
+    #[inline]
     pub fn max_pipeline_ray_recursion_depth(
         mut self,
         max_pipeline_ray_recursion_depth: u32,
@@ -31511,10 +36079,12 @@ impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
         self.inner.max_pipeline_ray_recursion_depth = max_pipeline_ray_recursion_depth;
         self
     }
+    #[inline]
     pub fn library_info(mut self, library_info: &'a PipelineLibraryCreateInfoKHR) -> Self {
         self.inner.p_library_info = library_info;
         self
     }
+    #[inline]
     pub fn library_interface(
         mut self,
         library_interface: &'a RayTracingPipelineInterfaceCreateInfoKHR,
@@ -31522,18 +36092,22 @@ impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
         self.inner.p_library_interface = library_interface;
         self
     }
+    #[inline]
     pub fn dynamic_state(mut self, dynamic_state: &'a PipelineDynamicStateCreateInfo) -> Self {
         self.inner.p_dynamic_state = dynamic_state;
         self
     }
+    #[inline]
     pub fn layout(mut self, layout: PipelineLayout) -> Self {
         self.inner.layout = layout;
         self
     }
+    #[inline]
     pub fn base_pipeline_handle(mut self, base_pipeline_handle: Pipeline) -> Self {
         self.inner.base_pipeline_handle = base_pipeline_handle;
         self
     }
+    #[inline]
     pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
         self.inner.base_pipeline_index = base_pipeline_index;
         self
@@ -31545,10 +36119,10 @@ impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsRayTracingPipelineCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -31560,8 +36134,9 @@ impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryTrianglesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryTrianglesNV.html>"]
 pub struct GeometryTrianglesNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -31578,9 +36153,10 @@ pub struct GeometryTrianglesNV {
     pub transform_offset: DeviceSize,
 }
 impl ::std::default::Default for GeometryTrianglesNV {
-    fn default() -> GeometryTrianglesNV {
-        GeometryTrianglesNV {
-            s_type: StructureType::GEOMETRY_TRIANGLES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             vertex_data: Buffer::default(),
             vertex_offset: DeviceSize::default(),
@@ -31596,10 +36172,13 @@ impl ::std::default::Default for GeometryTrianglesNV {
         }
     }
 }
+unsafe impl TaggedStructure for GeometryTrianglesNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_TRIANGLES_NV;
+}
 impl GeometryTrianglesNV {
     pub fn builder<'a>() -> GeometryTrianglesNVBuilder<'a> {
         GeometryTrianglesNVBuilder {
-            inner: GeometryTrianglesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31621,46 +36200,57 @@ impl<'a> ::std::ops::DerefMut for GeometryTrianglesNVBuilder<'a> {
     }
 }
 impl<'a> GeometryTrianglesNVBuilder<'a> {
+    #[inline]
     pub fn vertex_data(mut self, vertex_data: Buffer) -> Self {
         self.inner.vertex_data = vertex_data;
         self
     }
+    #[inline]
     pub fn vertex_offset(mut self, vertex_offset: DeviceSize) -> Self {
         self.inner.vertex_offset = vertex_offset;
         self
     }
+    #[inline]
     pub fn vertex_count(mut self, vertex_count: u32) -> Self {
         self.inner.vertex_count = vertex_count;
         self
     }
+    #[inline]
     pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self {
         self.inner.vertex_stride = vertex_stride;
         self
     }
+    #[inline]
     pub fn vertex_format(mut self, vertex_format: Format) -> Self {
         self.inner.vertex_format = vertex_format;
         self
     }
+    #[inline]
     pub fn index_data(mut self, index_data: Buffer) -> Self {
         self.inner.index_data = index_data;
         self
     }
+    #[inline]
     pub fn index_offset(mut self, index_offset: DeviceSize) -> Self {
         self.inner.index_offset = index_offset;
         self
     }
+    #[inline]
     pub fn index_count(mut self, index_count: u32) -> Self {
         self.inner.index_count = index_count;
         self
     }
+    #[inline]
     pub fn index_type(mut self, index_type: IndexType) -> Self {
         self.inner.index_type = index_type;
         self
     }
+    #[inline]
     pub fn transform_data(mut self, transform_data: Buffer) -> Self {
         self.inner.transform_data = transform_data;
         self
     }
+    #[inline]
     pub fn transform_offset(mut self, transform_offset: DeviceSize) -> Self {
         self.inner.transform_offset = transform_offset;
         self
@@ -31673,8 +36263,9 @@ impl<'a> GeometryTrianglesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryAABBNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryAABBNV.html>"]
 pub struct GeometryAABBNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -31684,9 +36275,10 @@ pub struct GeometryAABBNV {
     pub offset: DeviceSize,
 }
 impl ::std::default::Default for GeometryAABBNV {
-    fn default() -> GeometryAABBNV {
-        GeometryAABBNV {
-            s_type: StructureType::GEOMETRY_AABB_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             aabb_data: Buffer::default(),
             num_aab_bs: u32::default(),
@@ -31695,10 +36287,13 @@ impl ::std::default::Default for GeometryAABBNV {
         }
     }
 }
+unsafe impl TaggedStructure for GeometryAABBNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_AABB_NV;
+}
 impl GeometryAABBNV {
     pub fn builder<'a>() -> GeometryAABBNVBuilder<'a> {
         GeometryAABBNVBuilder {
-            inner: GeometryAABBNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31720,18 +36315,22 @@ impl<'a> ::std::ops::DerefMut for GeometryAABBNVBuilder<'a> {
     }
 }
 impl<'a> GeometryAABBNVBuilder<'a> {
+    #[inline]
     pub fn aabb_data(mut self, aabb_data: Buffer) -> Self {
         self.inner.aabb_data = aabb_data;
         self
     }
+    #[inline]
     pub fn num_aab_bs(mut self, num_aab_bs: u32) -> Self {
         self.inner.num_aab_bs = num_aab_bs;
         self
     }
+    #[inline]
     pub fn stride(mut self, stride: u32) -> Self {
         self.inner.stride = stride;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
@@ -31744,8 +36343,9 @@ impl<'a> GeometryAABBNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryDataNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryDataNV.html>"]
 pub struct GeometryDataNV {
     pub triangles: GeometryTrianglesNV,
     pub aabbs: GeometryAABBNV,
@@ -31753,7 +36353,7 @@ pub struct GeometryDataNV {
 impl GeometryDataNV {
     pub fn builder<'a>() -> GeometryDataNVBuilder<'a> {
         GeometryDataNVBuilder {
-            inner: GeometryDataNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31775,10 +36375,12 @@ impl<'a> ::std::ops::DerefMut for GeometryDataNVBuilder<'a> {
     }
 }
 impl<'a> GeometryDataNVBuilder<'a> {
+    #[inline]
     pub fn triangles(mut self, triangles: GeometryTrianglesNV) -> Self {
         self.inner.triangles = triangles;
         self
     }
+    #[inline]
     pub fn aabbs(mut self, aabbs: GeometryAABBNV) -> Self {
         self.inner.aabbs = aabbs;
         self
@@ -31791,8 +36393,9 @@ impl<'a> GeometryDataNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryNV.html>"]
 pub struct GeometryNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -31801,9 +36404,10 @@ pub struct GeometryNV {
     pub flags: GeometryFlagsKHR,
 }
 impl ::std::default::Default for GeometryNV {
-    fn default() -> GeometryNV {
-        GeometryNV {
-            s_type: StructureType::GEOMETRY_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             geometry_type: GeometryTypeKHR::default(),
             geometry: GeometryDataNV::default(),
@@ -31811,10 +36415,13 @@ impl ::std::default::Default for GeometryNV {
         }
     }
 }
+unsafe impl TaggedStructure for GeometryNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::GEOMETRY_NV;
+}
 impl GeometryNV {
     pub fn builder<'a>() -> GeometryNVBuilder<'a> {
         GeometryNVBuilder {
-            inner: GeometryNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31836,14 +36443,17 @@ impl<'a> ::std::ops::DerefMut for GeometryNVBuilder<'a> {
     }
 }
 impl<'a> GeometryNVBuilder<'a> {
+    #[inline]
     pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self {
         self.inner.geometry_type = geometry_type;
         self
     }
+    #[inline]
     pub fn geometry(mut self, geometry: GeometryDataNV) -> Self {
         self.inner.geometry = geometry;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
@@ -31856,8 +36466,9 @@ impl<'a> GeometryNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInfoNV.html>"]
 pub struct AccelerationStructureInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -31868,9 +36479,10 @@ pub struct AccelerationStructureInfoNV {
     pub p_geometries: *const GeometryNV,
 }
 impl ::std::default::Default for AccelerationStructureInfoNV {
-    fn default() -> AccelerationStructureInfoNV {
-        AccelerationStructureInfoNV {
-            s_type: StructureType::ACCELERATION_STRUCTURE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             ty: AccelerationStructureTypeNV::default(),
             flags: BuildAccelerationStructureFlagsNV::default(),
@@ -31880,10 +36492,13 @@ impl ::std::default::Default for AccelerationStructureInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_INFO_NV;
+}
 impl AccelerationStructureInfoNV {
     pub fn builder<'a>() -> AccelerationStructureInfoNVBuilder<'a> {
         AccelerationStructureInfoNVBuilder {
-            inner: AccelerationStructureInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31905,18 +36520,22 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureInfoNVBuilder<'a> {
     }
 }
 impl<'a> AccelerationStructureInfoNVBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: AccelerationStructureTypeNV) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: BuildAccelerationStructureFlagsNV) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn instance_count(mut self, instance_count: u32) -> Self {
         self.inner.instance_count = instance_count;
         self
     }
+    #[inline]
     pub fn geometries(mut self, geometries: &'a [GeometryNV]) -> Self {
         self.inner.geometry_count = geometries.len() as _;
         self.inner.p_geometries = geometries.as_ptr();
@@ -31930,8 +36549,9 @@ impl<'a> AccelerationStructureInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoNV.html>"]
 pub struct AccelerationStructureCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -31939,19 +36559,23 @@ pub struct AccelerationStructureCreateInfoNV {
     pub info: AccelerationStructureInfoNV,
 }
 impl ::std::default::Default for AccelerationStructureCreateInfoNV {
-    fn default() -> AccelerationStructureCreateInfoNV {
-        AccelerationStructureCreateInfoNV {
-            s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             compacted_size: DeviceSize::default(),
             info: AccelerationStructureInfoNV::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV;
+}
 impl AccelerationStructureCreateInfoNV {
     pub fn builder<'a>() -> AccelerationStructureCreateInfoNVBuilder<'a> {
         AccelerationStructureCreateInfoNVBuilder {
-            inner: AccelerationStructureCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -31961,6 +36585,7 @@ pub struct AccelerationStructureCreateInfoNVBuilder<'a> {
     inner: AccelerationStructureCreateInfoNV,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {}
 impl<'a> ::std::ops::Deref for AccelerationStructureCreateInfoNVBuilder<'a> {
     type Target = AccelerationStructureCreateInfoNV;
     fn deref(&self) -> &Self::Target {
@@ -31973,14 +36598,33 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoNVBuilder<'a> {
     }
 }
 impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn compacted_size(mut self, compacted_size: DeviceSize) -> Self {
         self.inner.compacted_size = compacted_size;
         self
     }
+    #[inline]
     pub fn info(mut self, info: AccelerationStructureInfoNV) -> Self {
         self.inner.info = info;
         self
     }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsAccelerationStructureCreateInfoNV>(
+        mut self,
+        next: &'a mut T,
+    ) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
@@ -31989,8 +36633,9 @@ impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBindAccelerationStructureMemoryInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindAccelerationStructureMemoryInfoNV.html>"]
 pub struct BindAccelerationStructureMemoryInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -32001,9 +36646,10 @@ pub struct BindAccelerationStructureMemoryInfoNV {
     pub p_device_indices: *const u32,
 }
 impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV {
-    fn default() -> BindAccelerationStructureMemoryInfoNV {
-        BindAccelerationStructureMemoryInfoNV {
-            s_type: StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             acceleration_structure: AccelerationStructureNV::default(),
             memory: DeviceMemory::default(),
@@ -32013,10 +36659,13 @@ impl ::std::default::Default for BindAccelerationStructureMemoryInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for BindAccelerationStructureMemoryInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV;
+}
 impl BindAccelerationStructureMemoryInfoNV {
     pub fn builder<'a>() -> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
         BindAccelerationStructureMemoryInfoNVBuilder {
-            inner: BindAccelerationStructureMemoryInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32038,6 +36687,7 @@ impl<'a> ::std::ops::DerefMut for BindAccelerationStructureMemoryInfoNVBuilder<'
     }
 }
 impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
+    #[inline]
     pub fn acceleration_structure(
         mut self,
         acceleration_structure: AccelerationStructureNV,
@@ -32045,14 +36695,17 @@ impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
         self.inner.acceleration_structure = acceleration_structure;
         self
     }
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
         self.inner.memory_offset = memory_offset;
         self
     }
+    #[inline]
     pub fn device_indices(mut self, device_indices: &'a [u32]) -> Self {
         self.inner.device_index_count = device_indices.len() as _;
         self.inner.p_device_indices = device_indices.as_ptr();
@@ -32066,8 +36719,9 @@ impl<'a> BindAccelerationStructureMemoryInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html>"]
 pub struct WriteDescriptorSetAccelerationStructureKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -32075,19 +36729,24 @@ pub struct WriteDescriptorSetAccelerationStructureKHR {
     pub p_acceleration_structures: *const AccelerationStructureKHR,
 }
 impl ::std::default::Default for WriteDescriptorSetAccelerationStructureKHR {
-    fn default() -> WriteDescriptorSetAccelerationStructureKHR {
-        WriteDescriptorSetAccelerationStructureKHR {
-            s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             acceleration_structure_count: u32::default(),
             p_acceleration_structures: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for WriteDescriptorSetAccelerationStructureKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
+}
 impl WriteDescriptorSetAccelerationStructureKHR {
     pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
         WriteDescriptorSetAccelerationStructureKHRBuilder {
-            inner: WriteDescriptorSetAccelerationStructureKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32111,6 +36770,7 @@ impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureKHRBuil
     }
 }
 impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
+    #[inline]
     pub fn acceleration_structures(
         mut self,
         acceleration_structures: &'a [AccelerationStructureKHR],
@@ -32127,8 +36787,9 @@ impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkWriteDescriptorSetAccelerationStructureNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkWriteDescriptorSetAccelerationStructureNV.html>"]
 pub struct WriteDescriptorSetAccelerationStructureNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -32136,19 +36797,24 @@ pub struct WriteDescriptorSetAccelerationStructureNV {
     pub p_acceleration_structures: *const AccelerationStructureNV,
 }
 impl ::std::default::Default for WriteDescriptorSetAccelerationStructureNV {
-    fn default() -> WriteDescriptorSetAccelerationStructureNV {
-        WriteDescriptorSetAccelerationStructureNV {
-            s_type: StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             acceleration_structure_count: u32::default(),
             p_acceleration_structures: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for WriteDescriptorSetAccelerationStructureNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
+}
 impl WriteDescriptorSetAccelerationStructureNV {
     pub fn builder<'a>() -> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
         WriteDescriptorSetAccelerationStructureNVBuilder {
-            inner: WriteDescriptorSetAccelerationStructureNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32172,6 +36838,7 @@ impl<'a> ::std::ops::DerefMut for WriteDescriptorSetAccelerationStructureNVBuild
     }
 }
 impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
+    #[inline]
     pub fn acceleration_structures(
         mut self,
         acceleration_structures: &'a [AccelerationStructureNV],
@@ -32188,8 +36855,9 @@ impl<'a> WriteDescriptorSetAccelerationStructureNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html>"]
 pub struct AccelerationStructureMemoryRequirementsInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -32197,19 +36865,24 @@ pub struct AccelerationStructureMemoryRequirementsInfoNV {
     pub acceleration_structure: AccelerationStructureNV,
 }
 impl ::std::default::Default for AccelerationStructureMemoryRequirementsInfoNV {
-    fn default() -> AccelerationStructureMemoryRequirementsInfoNV {
-        AccelerationStructureMemoryRequirementsInfoNV {
-            s_type: StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             ty: AccelerationStructureMemoryRequirementsTypeNV::default(),
             acceleration_structure: AccelerationStructureNV::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureMemoryRequirementsInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
+}
 impl AccelerationStructureMemoryRequirementsInfoNV {
     pub fn builder<'a>() -> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
         AccelerationStructureMemoryRequirementsInfoNVBuilder {
-            inner: AccelerationStructureMemoryRequirementsInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32231,10 +36904,12 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureMemoryRequirementsInfoNVB
     }
 }
 impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: AccelerationStructureMemoryRequirementsTypeNV) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn acceleration_structure(
         mut self,
         acceleration_structure: AccelerationStructureNV,
@@ -32250,8 +36925,9 @@ impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html>"]
 pub struct PhysicalDeviceAccelerationStructureFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -32262,9 +36938,10 @@ pub struct PhysicalDeviceAccelerationStructureFeaturesKHR {
     pub descriptor_binding_acceleration_structure_update_after_bind: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR {
-    fn default() -> PhysicalDeviceAccelerationStructureFeaturesKHR {
-        PhysicalDeviceAccelerationStructureFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             acceleration_structure: Bool32::default(),
             acceleration_structure_capture_replay: Bool32::default(),
@@ -32274,10 +36951,14 @@ impl ::std::default::Default for PhysicalDeviceAccelerationStructureFeaturesKHR
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceAccelerationStructureFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
+}
 impl PhysicalDeviceAccelerationStructureFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
         PhysicalDeviceAccelerationStructureFeaturesKHRBuilder {
-            inner: PhysicalDeviceAccelerationStructureFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32306,10 +36987,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructureFeaturesKHR
     }
 }
 impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn acceleration_structure(mut self, acceleration_structure: bool) -> Self {
         self.inner.acceleration_structure = acceleration_structure.into();
         self
     }
+    #[inline]
     pub fn acceleration_structure_capture_replay(
         mut self,
         acceleration_structure_capture_replay: bool,
@@ -32318,6 +37001,7 @@ impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
             acceleration_structure_capture_replay.into();
         self
     }
+    #[inline]
     pub fn acceleration_structure_indirect_build(
         mut self,
         acceleration_structure_indirect_build: bool,
@@ -32326,6 +37010,7 @@ impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
             acceleration_structure_indirect_build.into();
         self
     }
+    #[inline]
     pub fn acceleration_structure_host_commands(
         mut self,
         acceleration_structure_host_commands: bool,
@@ -32334,6 +37019,7 @@ impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
             acceleration_structure_host_commands.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_acceleration_structure_update_after_bind(
         mut self,
         descriptor_binding_acceleration_structure_update_after_bind: bool,
@@ -32351,8 +37037,9 @@ impl<'a> PhysicalDeviceAccelerationStructureFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html>"]
 pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -32363,9 +37050,10 @@ pub struct PhysicalDeviceRayTracingPipelineFeaturesKHR {
     pub ray_traversal_primitive_culling: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR {
-    fn default() -> PhysicalDeviceRayTracingPipelineFeaturesKHR {
-        PhysicalDeviceRayTracingPipelineFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             ray_tracing_pipeline: Bool32::default(),
             ray_tracing_pipeline_shader_group_handle_capture_replay: Bool32::default(),
@@ -32375,10 +37063,14 @@ impl ::std::default::Default for PhysicalDeviceRayTracingPipelineFeaturesKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceRayTracingPipelineFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
+}
 impl PhysicalDeviceRayTracingPipelineFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
         PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder {
-            inner: PhysicalDeviceRayTracingPipelineFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32407,10 +37099,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelineFeaturesKHRBui
     }
 }
 impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn ray_tracing_pipeline(mut self, ray_tracing_pipeline: bool) -> Self {
         self.inner.ray_tracing_pipeline = ray_tracing_pipeline.into();
         self
     }
+    #[inline]
     pub fn ray_tracing_pipeline_shader_group_handle_capture_replay(
         mut self,
         ray_tracing_pipeline_shader_group_handle_capture_replay: bool,
@@ -32420,6 +37114,7 @@ impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
             ray_tracing_pipeline_shader_group_handle_capture_replay.into();
         self
     }
+    #[inline]
     pub fn ray_tracing_pipeline_shader_group_handle_capture_replay_mixed(
         mut self,
         ray_tracing_pipeline_shader_group_handle_capture_replay_mixed: bool,
@@ -32429,6 +37124,7 @@ impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
             ray_tracing_pipeline_shader_group_handle_capture_replay_mixed.into();
         self
     }
+    #[inline]
     pub fn ray_tracing_pipeline_trace_rays_indirect(
         mut self,
         ray_tracing_pipeline_trace_rays_indirect: bool,
@@ -32437,6 +37133,7 @@ impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
             ray_tracing_pipeline_trace_rays_indirect.into();
         self
     }
+    #[inline]
     pub fn ray_traversal_primitive_culling(
         mut self,
         ray_traversal_primitive_culling: bool,
@@ -32452,26 +37149,31 @@ impl<'a> PhysicalDeviceRayTracingPipelineFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html>"]
 pub struct PhysicalDeviceRayQueryFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub ray_query: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceRayQueryFeaturesKHR {
-    fn default() -> PhysicalDeviceRayQueryFeaturesKHR {
-        PhysicalDeviceRayQueryFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             ray_query: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceRayQueryFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
+}
 impl PhysicalDeviceRayQueryFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
         PhysicalDeviceRayQueryFeaturesKHRBuilder {
-            inner: PhysicalDeviceRayQueryFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32497,6 +37199,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn ray_query(mut self, ray_query: bool) -> Self {
         self.inner.ray_query = ray_query.into();
         self
@@ -32509,8 +37212,9 @@ impl<'a> PhysicalDeviceRayQueryFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html>"]
 pub struct PhysicalDeviceAccelerationStructurePropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -32524,9 +37228,10 @@ pub struct PhysicalDeviceAccelerationStructurePropertiesKHR {
     pub min_acceleration_structure_scratch_offset_alignment: u32,
 }
 impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKHR {
-    fn default() -> PhysicalDeviceAccelerationStructurePropertiesKHR {
-        PhysicalDeviceAccelerationStructurePropertiesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_geometry_count: u64::default(),
             max_instance_count: u64::default(),
@@ -32539,10 +37244,14 @@ impl ::std::default::Default for PhysicalDeviceAccelerationStructurePropertiesKH
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceAccelerationStructurePropertiesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;
+}
 impl PhysicalDeviceAccelerationStructurePropertiesKHR {
     pub fn builder<'a>() -> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
         PhysicalDeviceAccelerationStructurePropertiesKHRBuilder {
-            inner: PhysicalDeviceAccelerationStructurePropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32569,18 +37278,22 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceAccelerationStructurePropertiesK
     }
 }
 impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self {
         self.inner.max_geometry_count = max_geometry_count;
         self
     }
+    #[inline]
     pub fn max_instance_count(mut self, max_instance_count: u64) -> Self {
         self.inner.max_instance_count = max_instance_count;
         self
     }
+    #[inline]
     pub fn max_primitive_count(mut self, max_primitive_count: u64) -> Self {
         self.inner.max_primitive_count = max_primitive_count;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_acceleration_structures(
         mut self,
         max_per_stage_descriptor_acceleration_structures: u32,
@@ -32589,6 +37302,7 @@ impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
             max_per_stage_descriptor_acceleration_structures;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_acceleration_structures(
         mut self,
         max_per_stage_descriptor_update_after_bind_acceleration_structures: u32,
@@ -32598,6 +37312,7 @@ impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_acceleration_structures;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_acceleration_structures(
         mut self,
         max_descriptor_set_acceleration_structures: u32,
@@ -32606,6 +37321,7 @@ impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
             max_descriptor_set_acceleration_structures;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_acceleration_structures(
         mut self,
         max_descriptor_set_update_after_bind_acceleration_structures: u32,
@@ -32615,6 +37331,7 @@ impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
             max_descriptor_set_update_after_bind_acceleration_structures;
         self
     }
+    #[inline]
     pub fn min_acceleration_structure_scratch_offset_alignment(
         mut self,
         min_acceleration_structure_scratch_offset_alignment: u32,
@@ -32632,8 +37349,9 @@ impl<'a> PhysicalDeviceAccelerationStructurePropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html>"]
 pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -32647,9 +37365,10 @@ pub struct PhysicalDeviceRayTracingPipelinePropertiesKHR {
     pub max_ray_hit_attribute_size: u32,
 }
 impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR {
-    fn default() -> PhysicalDeviceRayTracingPipelinePropertiesKHR {
-        PhysicalDeviceRayTracingPipelinePropertiesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_group_handle_size: u32::default(),
             max_ray_recursion_depth: u32::default(),
@@ -32662,10 +37381,14 @@ impl ::std::default::Default for PhysicalDeviceRayTracingPipelinePropertiesKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceRayTracingPipelinePropertiesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
+}
 impl PhysicalDeviceRayTracingPipelinePropertiesKHR {
     pub fn builder<'a>() -> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
         PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder {
-            inner: PhysicalDeviceRayTracingPipelinePropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32692,22 +37415,27 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPipelinePropertiesKHRB
     }
 }
 impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self {
         self.inner.shader_group_handle_size = shader_group_handle_size;
         self
     }
+    #[inline]
     pub fn max_ray_recursion_depth(mut self, max_ray_recursion_depth: u32) -> Self {
         self.inner.max_ray_recursion_depth = max_ray_recursion_depth;
         self
     }
+    #[inline]
     pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self {
         self.inner.max_shader_group_stride = max_shader_group_stride;
         self
     }
+    #[inline]
     pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self {
         self.inner.shader_group_base_alignment = shader_group_base_alignment;
         self
     }
+    #[inline]
     pub fn shader_group_handle_capture_replay_size(
         mut self,
         shader_group_handle_capture_replay_size: u32,
@@ -32716,6 +37444,7 @@ impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
             shader_group_handle_capture_replay_size;
         self
     }
+    #[inline]
     pub fn max_ray_dispatch_invocation_count(
         mut self,
         max_ray_dispatch_invocation_count: u32,
@@ -32723,10 +37452,12 @@ impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
         self.inner.max_ray_dispatch_invocation_count = max_ray_dispatch_invocation_count;
         self
     }
+    #[inline]
     pub fn shader_group_handle_alignment(mut self, shader_group_handle_alignment: u32) -> Self {
         self.inner.shader_group_handle_alignment = shader_group_handle_alignment;
         self
     }
+    #[inline]
     pub fn max_ray_hit_attribute_size(mut self, max_ray_hit_attribute_size: u32) -> Self {
         self.inner.max_ray_hit_attribute_size = max_ray_hit_attribute_size;
         self
@@ -32739,8 +37470,9 @@ impl<'a> PhysicalDeviceRayTracingPipelinePropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html>"]
 pub struct PhysicalDeviceRayTracingPropertiesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -32754,9 +37486,10 @@ pub struct PhysicalDeviceRayTracingPropertiesNV {
     pub max_descriptor_set_acceleration_structures: u32,
 }
 impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV {
-    fn default() -> PhysicalDeviceRayTracingPropertiesNV {
-        PhysicalDeviceRayTracingPropertiesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_group_handle_size: u32::default(),
             max_recursion_depth: u32::default(),
@@ -32769,10 +37502,13 @@ impl ::std::default::Default for PhysicalDeviceRayTracingPropertiesNV {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceRayTracingPropertiesNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
+}
 impl PhysicalDeviceRayTracingPropertiesNV {
     pub fn builder<'a>() -> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
         PhysicalDeviceRayTracingPropertiesNVBuilder {
-            inner: PhysicalDeviceRayTracingPropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32796,34 +37532,42 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPropertiesNVBuilder<'a
     }
 }
 impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
+    #[inline]
     pub fn shader_group_handle_size(mut self, shader_group_handle_size: u32) -> Self {
         self.inner.shader_group_handle_size = shader_group_handle_size;
         self
     }
+    #[inline]
     pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
         self.inner.max_recursion_depth = max_recursion_depth;
         self
     }
+    #[inline]
     pub fn max_shader_group_stride(mut self, max_shader_group_stride: u32) -> Self {
         self.inner.max_shader_group_stride = max_shader_group_stride;
         self
     }
+    #[inline]
     pub fn shader_group_base_alignment(mut self, shader_group_base_alignment: u32) -> Self {
         self.inner.shader_group_base_alignment = shader_group_base_alignment;
         self
     }
+    #[inline]
     pub fn max_geometry_count(mut self, max_geometry_count: u64) -> Self {
         self.inner.max_geometry_count = max_geometry_count;
         self
     }
+    #[inline]
     pub fn max_instance_count(mut self, max_instance_count: u64) -> Self {
         self.inner.max_instance_count = max_instance_count;
         self
     }
+    #[inline]
     pub fn max_triangle_count(mut self, max_triangle_count: u64) -> Self {
         self.inner.max_triangle_count = max_triangle_count;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_acceleration_structures(
         mut self,
         max_descriptor_set_acceleration_structures: u32,
@@ -32840,8 +37584,9 @@ impl<'a> PhysicalDeviceRayTracingPropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStridedDeviceAddressRegionKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStridedDeviceAddressRegionKHR.html>"]
 pub struct StridedDeviceAddressRegionKHR {
     pub device_address: DeviceAddress,
     pub stride: DeviceSize,
@@ -32850,7 +37595,7 @@ pub struct StridedDeviceAddressRegionKHR {
 impl StridedDeviceAddressRegionKHR {
     pub fn builder<'a>() -> StridedDeviceAddressRegionKHRBuilder<'a> {
         StridedDeviceAddressRegionKHRBuilder {
-            inner: StridedDeviceAddressRegionKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32872,14 +37617,17 @@ impl<'a> ::std::ops::DerefMut for StridedDeviceAddressRegionKHRBuilder<'a> {
     }
 }
 impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> {
+    #[inline]
     pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
         self.inner.device_address = device_address;
         self
     }
+    #[inline]
     pub fn stride(mut self, stride: DeviceSize) -> Self {
         self.inner.stride = stride;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
@@ -32892,8 +37640,9 @@ impl<'a> StridedDeviceAddressRegionKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTraceRaysIndirectCommandKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTraceRaysIndirectCommandKHR.html>"]
 pub struct TraceRaysIndirectCommandKHR {
     pub width: u32,
     pub height: u32,
@@ -32902,7 +37651,7 @@ pub struct TraceRaysIndirectCommandKHR {
 impl TraceRaysIndirectCommandKHR {
     pub fn builder<'a>() -> TraceRaysIndirectCommandKHRBuilder<'a> {
         TraceRaysIndirectCommandKHRBuilder {
-            inner: TraceRaysIndirectCommandKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32924,14 +37673,17 @@ impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommandKHRBuilder<'a> {
     }
 }
 impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> {
+    #[inline]
     pub fn width(mut self, width: u32) -> Self {
         self.inner.width = width;
         self
     }
+    #[inline]
     pub fn height(mut self, height: u32) -> Self {
         self.inner.height = height;
         self
     }
+    #[inline]
     pub fn depth(mut self, depth: u32) -> Self {
         self.inner.depth = depth;
         self
@@ -32944,8 +37696,239 @@ impl<'a> TraceRaysIndirectCommandKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrmFormatModifierPropertiesListEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTraceRaysIndirectCommand2KHR.html>"]
+pub struct TraceRaysIndirectCommand2KHR {
+    pub raygen_shader_record_address: DeviceAddress,
+    pub raygen_shader_record_size: DeviceSize,
+    pub miss_shader_binding_table_address: DeviceAddress,
+    pub miss_shader_binding_table_size: DeviceSize,
+    pub miss_shader_binding_table_stride: DeviceSize,
+    pub hit_shader_binding_table_address: DeviceAddress,
+    pub hit_shader_binding_table_size: DeviceSize,
+    pub hit_shader_binding_table_stride: DeviceSize,
+    pub callable_shader_binding_table_address: DeviceAddress,
+    pub callable_shader_binding_table_size: DeviceSize,
+    pub callable_shader_binding_table_stride: DeviceSize,
+    pub width: u32,
+    pub height: u32,
+    pub depth: u32,
+}
+impl TraceRaysIndirectCommand2KHR {
+    pub fn builder<'a>() -> TraceRaysIndirectCommand2KHRBuilder<'a> {
+        TraceRaysIndirectCommand2KHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct TraceRaysIndirectCommand2KHRBuilder<'a> {
+    inner: TraceRaysIndirectCommand2KHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for TraceRaysIndirectCommand2KHRBuilder<'a> {
+    type Target = TraceRaysIndirectCommand2KHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for TraceRaysIndirectCommand2KHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> TraceRaysIndirectCommand2KHRBuilder<'a> {
+    #[inline]
+    pub fn raygen_shader_record_address(
+        mut self,
+        raygen_shader_record_address: DeviceAddress,
+    ) -> Self {
+        self.inner.raygen_shader_record_address = raygen_shader_record_address;
+        self
+    }
+    #[inline]
+    pub fn raygen_shader_record_size(mut self, raygen_shader_record_size: DeviceSize) -> Self {
+        self.inner.raygen_shader_record_size = raygen_shader_record_size;
+        self
+    }
+    #[inline]
+    pub fn miss_shader_binding_table_address(
+        mut self,
+        miss_shader_binding_table_address: DeviceAddress,
+    ) -> Self {
+        self.inner.miss_shader_binding_table_address = miss_shader_binding_table_address;
+        self
+    }
+    #[inline]
+    pub fn miss_shader_binding_table_size(
+        mut self,
+        miss_shader_binding_table_size: DeviceSize,
+    ) -> Self {
+        self.inner.miss_shader_binding_table_size = miss_shader_binding_table_size;
+        self
+    }
+    #[inline]
+    pub fn miss_shader_binding_table_stride(
+        mut self,
+        miss_shader_binding_table_stride: DeviceSize,
+    ) -> Self {
+        self.inner.miss_shader_binding_table_stride = miss_shader_binding_table_stride;
+        self
+    }
+    #[inline]
+    pub fn hit_shader_binding_table_address(
+        mut self,
+        hit_shader_binding_table_address: DeviceAddress,
+    ) -> Self {
+        self.inner.hit_shader_binding_table_address = hit_shader_binding_table_address;
+        self
+    }
+    #[inline]
+    pub fn hit_shader_binding_table_size(
+        mut self,
+        hit_shader_binding_table_size: DeviceSize,
+    ) -> Self {
+        self.inner.hit_shader_binding_table_size = hit_shader_binding_table_size;
+        self
+    }
+    #[inline]
+    pub fn hit_shader_binding_table_stride(
+        mut self,
+        hit_shader_binding_table_stride: DeviceSize,
+    ) -> Self {
+        self.inner.hit_shader_binding_table_stride = hit_shader_binding_table_stride;
+        self
+    }
+    #[inline]
+    pub fn callable_shader_binding_table_address(
+        mut self,
+        callable_shader_binding_table_address: DeviceAddress,
+    ) -> Self {
+        self.inner.callable_shader_binding_table_address = callable_shader_binding_table_address;
+        self
+    }
+    #[inline]
+    pub fn callable_shader_binding_table_size(
+        mut self,
+        callable_shader_binding_table_size: DeviceSize,
+    ) -> Self {
+        self.inner.callable_shader_binding_table_size = callable_shader_binding_table_size;
+        self
+    }
+    #[inline]
+    pub fn callable_shader_binding_table_stride(
+        mut self,
+        callable_shader_binding_table_stride: DeviceSize,
+    ) -> Self {
+        self.inner.callable_shader_binding_table_stride = callable_shader_binding_table_stride;
+        self
+    }
+    #[inline]
+    pub fn width(mut self, width: u32) -> Self {
+        self.inner.width = width;
+        self
+    }
+    #[inline]
+    pub fn height(mut self, height: u32) -> Self {
+        self.inner.height = height;
+        self
+    }
+    #[inline]
+    pub fn depth(mut self, depth: u32) -> Self {
+        self.inner.depth = depth;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> TraceRaysIndirectCommand2KHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.html>"]
+pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub ray_tracing_maintenance1: Bool32,
+    pub ray_tracing_pipeline_trace_rays_indirect2: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            ray_tracing_maintenance1: Bool32::default(),
+            ray_tracing_pipeline_trace_rays_indirect2: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR;
+}
+impl PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
+    pub fn builder<'a>() -> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
+        PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
+    inner: PhysicalDeviceRayTracingMaintenance1FeaturesKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMaintenance1FeaturesKHR {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
+    type Target = PhysicalDeviceRayTracingMaintenance1FeaturesKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceRayTracingMaintenance1FeaturesKHRBuilder<'a> {
+    #[inline]
+    pub fn ray_tracing_maintenance1(mut self, ray_tracing_maintenance1: bool) -> Self {
+        self.inner.ray_tracing_maintenance1 = ray_tracing_maintenance1.into();
+        self
+    }
+    #[inline]
+    pub fn ray_tracing_pipeline_trace_rays_indirect2(
+        mut self,
+        ray_tracing_pipeline_trace_rays_indirect2: bool,
+    ) -> Self {
+        self.inner.ray_tracing_pipeline_trace_rays_indirect2 =
+            ray_tracing_pipeline_trace_rays_indirect2.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesListEXT.html>"]
 pub struct DrmFormatModifierPropertiesListEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -32953,19 +37936,23 @@ pub struct DrmFormatModifierPropertiesListEXT {
     pub p_drm_format_modifier_properties: *mut DrmFormatModifierPropertiesEXT,
 }
 impl ::std::default::Default for DrmFormatModifierPropertiesListEXT {
-    fn default() -> DrmFormatModifierPropertiesListEXT {
-        DrmFormatModifierPropertiesListEXT {
-            s_type: StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             drm_format_modifier_count: u32::default(),
             p_drm_format_modifier_properties: ::std::ptr::null_mut(),
         }
     }
 }
+unsafe impl TaggedStructure for DrmFormatModifierPropertiesListEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT;
+}
 impl DrmFormatModifierPropertiesListEXT {
     pub fn builder<'a>() -> DrmFormatModifierPropertiesListEXTBuilder<'a> {
         DrmFormatModifierPropertiesListEXTBuilder {
-            inner: DrmFormatModifierPropertiesListEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -32989,6 +37976,7 @@ impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesListEXTBuilder<'a>
     }
 }
 impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> {
+    #[inline]
     pub fn drm_format_modifier_properties(
         mut self,
         drm_format_modifier_properties: &'a mut [DrmFormatModifierPropertiesEXT],
@@ -33005,8 +37993,9 @@ impl<'a> DrmFormatModifierPropertiesListEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDrmFormatModifierPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesEXT.html>"]
 pub struct DrmFormatModifierPropertiesEXT {
     pub drm_format_modifier: u64,
     pub drm_format_modifier_plane_count: u32,
@@ -33015,7 +38004,7 @@ pub struct DrmFormatModifierPropertiesEXT {
 impl DrmFormatModifierPropertiesEXT {
     pub fn builder<'a>() -> DrmFormatModifierPropertiesEXTBuilder<'a> {
         DrmFormatModifierPropertiesEXTBuilder {
-            inner: DrmFormatModifierPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33037,14 +38026,17 @@ impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesEXTBuilder<'a> {
     }
 }
 impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
         self.inner.drm_format_modifier = drm_format_modifier;
         self
     }
+    #[inline]
     pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self {
         self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
         self
     }
+    #[inline]
     pub fn drm_format_modifier_tiling_features(
         mut self,
         drm_format_modifier_tiling_features: FormatFeatureFlags,
@@ -33060,8 +38052,9 @@ impl<'a> DrmFormatModifierPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html>"]
 pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -33071,9 +38064,10 @@ pub struct PhysicalDeviceImageDrmFormatModifierInfoEXT {
     pub p_queue_family_indices: *const u32,
 }
 impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT {
-    fn default() -> PhysicalDeviceImageDrmFormatModifierInfoEXT {
-        PhysicalDeviceImageDrmFormatModifierInfoEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             drm_format_modifier: u64::default(),
             sharing_mode: SharingMode::default(),
@@ -33082,10 +38076,14 @@ impl ::std::default::Default for PhysicalDeviceImageDrmFormatModifierInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceImageDrmFormatModifierInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT;
+}
 impl PhysicalDeviceImageDrmFormatModifierInfoEXT {
     pub fn builder<'a>() -> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
         PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder {
-            inner: PhysicalDeviceImageDrmFormatModifierInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33112,14 +38110,17 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageDrmFormatModifierInfoEXTBui
     }
 }
 impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
+    #[inline]
     pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
         self.inner.drm_format_modifier = drm_format_modifier;
         self
     }
+    #[inline]
     pub fn sharing_mode(mut self, sharing_mode: SharingMode) -> Self {
         self.inner.sharing_mode = sharing_mode;
         self
     }
+    #[inline]
     pub fn queue_family_indices(mut self, queue_family_indices: &'a [u32]) -> Self {
         self.inner.queue_family_index_count = queue_family_indices.len() as _;
         self.inner.p_queue_family_indices = queue_family_indices.as_ptr();
@@ -33133,8 +38134,9 @@ impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html>"]
 pub struct ImageDrmFormatModifierListCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -33142,19 +38144,24 @@ pub struct ImageDrmFormatModifierListCreateInfoEXT {
     pub p_drm_format_modifiers: *const u64,
 }
 impl ::std::default::Default for ImageDrmFormatModifierListCreateInfoEXT {
-    fn default() -> ImageDrmFormatModifierListCreateInfoEXT {
-        ImageDrmFormatModifierListCreateInfoEXT {
-            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             drm_format_modifier_count: u32::default(),
             p_drm_format_modifiers: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageDrmFormatModifierListCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT;
+}
 impl ImageDrmFormatModifierListCreateInfoEXT {
     pub fn builder<'a>() -> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
         ImageDrmFormatModifierListCreateInfoEXTBuilder {
-            inner: ImageDrmFormatModifierListCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33178,6 +38185,7 @@ impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierListCreateInfoEXTBuilder
     }
 }
 impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn drm_format_modifiers(mut self, drm_format_modifiers: &'a [u64]) -> Self {
         self.inner.drm_format_modifier_count = drm_format_modifiers.len() as _;
         self.inner.p_drm_format_modifiers = drm_format_modifiers.as_ptr();
@@ -33191,8 +38199,9 @@ impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html>"]
 pub struct ImageDrmFormatModifierExplicitCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -33201,9 +38210,10 @@ pub struct ImageDrmFormatModifierExplicitCreateInfoEXT {
     pub p_plane_layouts: *const SubresourceLayout,
 }
 impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT {
-    fn default() -> ImageDrmFormatModifierExplicitCreateInfoEXT {
-        ImageDrmFormatModifierExplicitCreateInfoEXT {
-            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             drm_format_modifier: u64::default(),
             drm_format_modifier_plane_count: u32::default(),
@@ -33211,10 +38221,14 @@ impl ::std::default::Default for ImageDrmFormatModifierExplicitCreateInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for ImageDrmFormatModifierExplicitCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT;
+}
 impl ImageDrmFormatModifierExplicitCreateInfoEXT {
     pub fn builder<'a>() -> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
         ImageDrmFormatModifierExplicitCreateInfoEXTBuilder {
-            inner: ImageDrmFormatModifierExplicitCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33238,10 +38252,12 @@ impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierExplicitCreateInfoEXTBui
     }
 }
 impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
         self.inner.drm_format_modifier = drm_format_modifier;
         self
     }
+    #[inline]
     pub fn plane_layouts(mut self, plane_layouts: &'a [SubresourceLayout]) -> Self {
         self.inner.drm_format_modifier_plane_count = plane_layouts.len() as _;
         self.inner.p_plane_layouts = plane_layouts.as_ptr();
@@ -33255,26 +38271,31 @@ impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageDrmFormatModifierPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageDrmFormatModifierPropertiesEXT.html>"]
 pub struct ImageDrmFormatModifierPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub drm_format_modifier: u64,
 }
 impl ::std::default::Default for ImageDrmFormatModifierPropertiesEXT {
-    fn default() -> ImageDrmFormatModifierPropertiesEXT {
-        ImageDrmFormatModifierPropertiesEXT {
-            s_type: StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             drm_format_modifier: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageDrmFormatModifierPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT;
+}
 impl ImageDrmFormatModifierPropertiesEXT {
     pub fn builder<'a>() -> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
         ImageDrmFormatModifierPropertiesEXTBuilder {
-            inner: ImageDrmFormatModifierPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33296,6 +38317,7 @@ impl<'a> ::std::ops::DerefMut for ImageDrmFormatModifierPropertiesEXTBuilder<'a>
     }
 }
 impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
         self.inner.drm_format_modifier = drm_format_modifier;
         self
@@ -33308,26 +38330,31 @@ impl<'a> ImageDrmFormatModifierPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageStencilUsageCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageStencilUsageCreateInfo.html>"]
 pub struct ImageStencilUsageCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub stencil_usage: ImageUsageFlags,
 }
 impl ::std::default::Default for ImageStencilUsageCreateInfo {
-    fn default() -> ImageStencilUsageCreateInfo {
-        ImageStencilUsageCreateInfo {
-            s_type: StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             stencil_usage: ImageUsageFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageStencilUsageCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_STENCIL_USAGE_CREATE_INFO;
+}
 impl ImageStencilUsageCreateInfo {
     pub fn builder<'a>() -> ImageStencilUsageCreateInfoBuilder<'a> {
         ImageStencilUsageCreateInfoBuilder {
-            inner: ImageStencilUsageCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33353,6 +38380,7 @@ impl<'a> ::std::ops::DerefMut for ImageStencilUsageCreateInfoBuilder<'a> {
     }
 }
 impl<'a> ImageStencilUsageCreateInfoBuilder<'a> {
+    #[inline]
     pub fn stencil_usage(mut self, stencil_usage: ImageUsageFlags) -> Self {
         self.inner.stencil_usage = stencil_usage;
         self
@@ -33365,26 +38393,32 @@ impl<'a> ImageStencilUsageCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html>"]
 pub struct DeviceMemoryOverallocationCreateInfoAMD {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub overallocation_behavior: MemoryOverallocationBehaviorAMD,
 }
 impl ::std::default::Default for DeviceMemoryOverallocationCreateInfoAMD {
-    fn default() -> DeviceMemoryOverallocationCreateInfoAMD {
-        DeviceMemoryOverallocationCreateInfoAMD {
-            s_type: StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             overallocation_behavior: MemoryOverallocationBehaviorAMD::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DeviceMemoryOverallocationCreateInfoAMD {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD;
+}
 impl DeviceMemoryOverallocationCreateInfoAMD {
     pub fn builder<'a>() -> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
         DeviceMemoryOverallocationCreateInfoAMDBuilder {
-            inner: DeviceMemoryOverallocationCreateInfoAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33408,6 +38442,7 @@ impl<'a> ::std::ops::DerefMut for DeviceMemoryOverallocationCreateInfoAMDBuilder
     }
 }
 impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
+    #[inline]
     pub fn overallocation_behavior(
         mut self,
         overallocation_behavior: MemoryOverallocationBehaviorAMD,
@@ -33423,8 +38458,9 @@ impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html>"]
 pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -33433,9 +38469,10 @@ pub struct PhysicalDeviceFragmentDensityMapFeaturesEXT {
     pub fragment_density_map_non_subsampled_images: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT {
-    fn default() -> PhysicalDeviceFragmentDensityMapFeaturesEXT {
-        PhysicalDeviceFragmentDensityMapFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             fragment_density_map: Bool32::default(),
             fragment_density_map_dynamic: Bool32::default(),
@@ -33443,10 +38480,14 @@ impl ::std::default::Default for PhysicalDeviceFragmentDensityMapFeaturesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT;
+}
 impl PhysicalDeviceFragmentDensityMapFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
         PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder {
-            inner: PhysicalDeviceFragmentDensityMapFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33475,14 +38516,17 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapFeaturesEXTBui
     }
 }
 impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn fragment_density_map(mut self, fragment_density_map: bool) -> Self {
         self.inner.fragment_density_map = fragment_density_map.into();
         self
     }
+    #[inline]
     pub fn fragment_density_map_dynamic(mut self, fragment_density_map_dynamic: bool) -> Self {
         self.inner.fragment_density_map_dynamic = fragment_density_map_dynamic.into();
         self
     }
+    #[inline]
     pub fn fragment_density_map_non_subsampled_images(
         mut self,
         fragment_density_map_non_subsampled_images: bool,
@@ -33499,26 +38543,32 @@ impl<'a> PhysicalDeviceFragmentDensityMapFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html>"]
 pub struct PhysicalDeviceFragmentDensityMap2FeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub fragment_density_map_deferred: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2FeaturesEXT {
-    fn default() -> PhysicalDeviceFragmentDensityMap2FeaturesEXT {
-        PhysicalDeviceFragmentDensityMap2FeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             fragment_density_map_deferred: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMap2FeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT;
+}
 impl PhysicalDeviceFragmentDensityMap2FeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
         PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder {
-            inner: PhysicalDeviceFragmentDensityMap2FeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33547,6 +38597,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2FeaturesEXTBu
     }
 }
 impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn fragment_density_map_deferred(mut self, fragment_density_map_deferred: bool) -> Self {
         self.inner.fragment_density_map_deferred = fragment_density_map_deferred.into();
         self
@@ -33559,8 +38610,79 @@ impl<'a> PhysicalDeviceFragmentDensityMap2FeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM.html>"]
+pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub fragment_density_map_offset: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            fragment_density_map_offset: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM;
+}
+impl PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
+        PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
+    inner: PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
+    type Target = PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOMBuilder<'a> {
+    #[inline]
+    pub fn fragment_density_map_offset(mut self, fragment_density_map_offset: bool) -> Self {
+        self.inner.fragment_density_map_offset = fragment_density_map_offset.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html>"]
 pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -33569,9 +38691,10 @@ pub struct PhysicalDeviceFragmentDensityMapPropertiesEXT {
     pub fragment_density_invocations: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT {
-    fn default() -> PhysicalDeviceFragmentDensityMapPropertiesEXT {
-        PhysicalDeviceFragmentDensityMapPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             min_fragment_density_texel_size: Extent2D::default(),
             max_fragment_density_texel_size: Extent2D::default(),
@@ -33579,10 +38702,14 @@ impl ::std::default::Default for PhysicalDeviceFragmentDensityMapPropertiesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT;
+}
 impl PhysicalDeviceFragmentDensityMapPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
         PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder {
-            inner: PhysicalDeviceFragmentDensityMapPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33609,6 +38736,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapPropertiesEXTB
     }
 }
 impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn min_fragment_density_texel_size(
         mut self,
         min_fragment_density_texel_size: Extent2D,
@@ -33616,6 +38744,7 @@ impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
         self.inner.min_fragment_density_texel_size = min_fragment_density_texel_size;
         self
     }
+    #[inline]
     pub fn max_fragment_density_texel_size(
         mut self,
         max_fragment_density_texel_size: Extent2D,
@@ -33623,6 +38752,7 @@ impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
         self.inner.max_fragment_density_texel_size = max_fragment_density_texel_size;
         self
     }
+    #[inline]
     pub fn fragment_density_invocations(mut self, fragment_density_invocations: bool) -> Self {
         self.inner.fragment_density_invocations = fragment_density_invocations.into();
         self
@@ -33635,8 +38765,9 @@ impl<'a> PhysicalDeviceFragmentDensityMapPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html>"]
 pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -33646,9 +38777,10 @@ pub struct PhysicalDeviceFragmentDensityMap2PropertiesEXT {
     pub max_descriptor_set_subsampled_samplers: u32,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT {
-    fn default() -> PhysicalDeviceFragmentDensityMap2PropertiesEXT {
-        PhysicalDeviceFragmentDensityMap2PropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             subsampled_loads: Bool32::default(),
             subsampled_coarse_reconstruction_early_access: Bool32::default(),
@@ -33657,10 +38789,14 @@ impl ::std::default::Default for PhysicalDeviceFragmentDensityMap2PropertiesEXT
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMap2PropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT;
+}
 impl PhysicalDeviceFragmentDensityMap2PropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
         PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder {
-            inner: PhysicalDeviceFragmentDensityMap2PropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33687,10 +38823,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMap2PropertiesEXT
     }
 }
 impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn subsampled_loads(mut self, subsampled_loads: bool) -> Self {
         self.inner.subsampled_loads = subsampled_loads.into();
         self
     }
+    #[inline]
     pub fn subsampled_coarse_reconstruction_early_access(
         mut self,
         subsampled_coarse_reconstruction_early_access: bool,
@@ -33699,10 +38837,12 @@ impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
             subsampled_coarse_reconstruction_early_access.into();
         self
     }
+    #[inline]
     pub fn max_subsampled_array_layers(mut self, max_subsampled_array_layers: u32) -> Self {
         self.inner.max_subsampled_array_layers = max_subsampled_array_layers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_subsampled_samplers(
         mut self,
         max_descriptor_set_subsampled_samplers: u32,
@@ -33718,26 +38858,103 @@ impl<'a> PhysicalDeviceFragmentDensityMap2PropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM.html>"]
+pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub fragment_density_offset_granularity: Extent2D,
+}
+impl ::std::default::Default for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            fragment_density_offset_granularity: Extent2D::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM;
+}
+impl PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+    pub fn builder<'a>() -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
+        PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
+    inner: PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM
+{
+}
+impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
+    type Target = PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOMBuilder<'a> {
+    #[inline]
+    pub fn fragment_density_offset_granularity(
+        mut self,
+        fragment_density_offset_granularity: Extent2D,
+    ) -> Self {
+        self.inner.fragment_density_offset_granularity = fragment_density_offset_granularity;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html>"]
 pub struct RenderPassFragmentDensityMapCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub fragment_density_map_attachment: AttachmentReference,
 }
 impl ::std::default::Default for RenderPassFragmentDensityMapCreateInfoEXT {
-    fn default() -> RenderPassFragmentDensityMapCreateInfoEXT {
-        RenderPassFragmentDensityMapCreateInfoEXT {
-            s_type: StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             fragment_density_map_attachment: AttachmentReference::default(),
         }
     }
 }
+unsafe impl TaggedStructure for RenderPassFragmentDensityMapCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT;
+}
 impl RenderPassFragmentDensityMapCreateInfoEXT {
     pub fn builder<'a>() -> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
         RenderPassFragmentDensityMapCreateInfoEXTBuilder {
-            inner: RenderPassFragmentDensityMapCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33763,6 +38980,7 @@ impl<'a> ::std::ops::DerefMut for RenderPassFragmentDensityMapCreateInfoEXTBuild
     }
 }
 impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn fragment_density_map_attachment(
         mut self,
         fragment_density_map_attachment: AttachmentReference,
@@ -33778,26 +38996,97 @@ impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassFragmentDensityMapOffsetEndInfoQCOM.html>"]
+pub struct SubpassFragmentDensityMapOffsetEndInfoQCOM {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub fragment_density_offset_count: u32,
+    pub p_fragment_density_offsets: *const Offset2D,
+}
+impl ::std::default::Default for SubpassFragmentDensityMapOffsetEndInfoQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            fragment_density_offset_count: u32::default(),
+            p_fragment_density_offsets: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SubpassFragmentDensityMapOffsetEndInfoQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM;
+}
+impl SubpassFragmentDensityMapOffsetEndInfoQCOM {
+    pub fn builder<'a>() -> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
+        SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
+    inner: SubpassFragmentDensityMapOffsetEndInfoQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'_> {}
+unsafe impl ExtendsSubpassEndInfo for SubpassFragmentDensityMapOffsetEndInfoQCOM {}
+impl<'a> ::std::ops::Deref for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
+    type Target = SubpassFragmentDensityMapOffsetEndInfoQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SubpassFragmentDensityMapOffsetEndInfoQCOMBuilder<'a> {
+    #[inline]
+    pub fn fragment_density_offsets(mut self, fragment_density_offsets: &'a [Offset2D]) -> Self {
+        self.inner.fragment_density_offset_count = fragment_density_offsets.len() as _;
+        self.inner.p_fragment_density_offsets = fragment_density_offsets.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SubpassFragmentDensityMapOffsetEndInfoQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html>"]
 pub struct PhysicalDeviceScalarBlockLayoutFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub scalar_block_layout: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceScalarBlockLayoutFeatures {
-    fn default() -> PhysicalDeviceScalarBlockLayoutFeatures {
-        PhysicalDeviceScalarBlockLayoutFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             scalar_block_layout: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceScalarBlockLayoutFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
+}
 impl PhysicalDeviceScalarBlockLayoutFeatures {
     pub fn builder<'a>() -> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
         PhysicalDeviceScalarBlockLayoutFeaturesBuilder {
-            inner: PhysicalDeviceScalarBlockLayoutFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33823,6 +39112,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceScalarBlockLayoutFeaturesBuilder
     }
 }
 impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
+    #[inline]
     pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
         self.inner.scalar_block_layout = scalar_block_layout.into();
         self
@@ -33835,26 +39125,31 @@ impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceProtectedCapabilitiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceProtectedCapabilitiesKHR.html>"]
 pub struct SurfaceProtectedCapabilitiesKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub supports_protected: Bool32,
 }
 impl ::std::default::Default for SurfaceProtectedCapabilitiesKHR {
-    fn default() -> SurfaceProtectedCapabilitiesKHR {
-        SurfaceProtectedCapabilitiesKHR {
-            s_type: StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             supports_protected: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SurfaceProtectedCapabilitiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PROTECTED_CAPABILITIES_KHR;
+}
 impl SurfaceProtectedCapabilitiesKHR {
     pub fn builder<'a>() -> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
         SurfaceProtectedCapabilitiesKHRBuilder {
-            inner: SurfaceProtectedCapabilitiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33878,6 +39173,7 @@ impl<'a> ::std::ops::DerefMut for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
     }
 }
 impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
+    #[inline]
     pub fn supports_protected(mut self, supports_protected: bool) -> Self {
         self.inner.supports_protected = supports_protected.into();
         self
@@ -33890,26 +39186,32 @@ impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html>"]
 pub struct PhysicalDeviceUniformBufferStandardLayoutFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub uniform_buffer_standard_layout: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceUniformBufferStandardLayoutFeatures {
-    fn default() -> PhysicalDeviceUniformBufferStandardLayoutFeatures {
-        PhysicalDeviceUniformBufferStandardLayoutFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             uniform_buffer_standard_layout: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceUniformBufferStandardLayoutFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
+}
 impl PhysicalDeviceUniformBufferStandardLayoutFeatures {
     pub fn builder<'a>() -> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
         PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder {
-            inner: PhysicalDeviceUniformBufferStandardLayoutFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33941,6 +39243,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceUniformBufferStandardLayoutFeatu
     }
 }
 impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
+    #[inline]
     pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
         self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
         self
@@ -33953,26 +39256,32 @@ impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html>"]
 pub struct PhysicalDeviceDepthClipEnableFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub depth_clip_enable: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceDepthClipEnableFeaturesEXT {
-    fn default() -> PhysicalDeviceDepthClipEnableFeaturesEXT {
-        PhysicalDeviceDepthClipEnableFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             depth_clip_enable: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDepthClipEnableFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT;
+}
 impl PhysicalDeviceDepthClipEnableFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
         PhysicalDeviceDepthClipEnableFeaturesEXTBuilder {
-            inner: PhysicalDeviceDepthClipEnableFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -33998,6 +39307,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipEnableFeaturesEXTBuilde
     }
 }
 impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
         self.inner.depth_clip_enable = depth_clip_enable.into();
         self
@@ -34010,8 +39320,9 @@ impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html>"]
 pub struct PipelineRasterizationDepthClipStateCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -34019,19 +39330,24 @@ pub struct PipelineRasterizationDepthClipStateCreateInfoEXT {
     pub depth_clip_enable: Bool32,
 }
 impl ::std::default::Default for PipelineRasterizationDepthClipStateCreateInfoEXT {
-    fn default() -> PipelineRasterizationDepthClipStateCreateInfoEXT {
-        PipelineRasterizationDepthClipStateCreateInfoEXT {
-            s_type: StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineRasterizationDepthClipStateCreateFlagsEXT::default(),
             depth_clip_enable: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineRasterizationDepthClipStateCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT;
+}
 impl PipelineRasterizationDepthClipStateCreateInfoEXT {
     pub fn builder<'a>() -> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
         PipelineRasterizationDepthClipStateCreateInfoEXTBuilder {
-            inner: PipelineRasterizationDepthClipStateCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34061,10 +39377,12 @@ impl<'a> ::std::ops::DerefMut for PipelineRasterizationDepthClipStateCreateInfoE
     }
 }
 impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineRasterizationDepthClipStateCreateFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
         self.inner.depth_clip_enable = depth_clip_enable.into();
         self
@@ -34077,8 +39395,9 @@ impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html>"]
 pub struct PhysicalDeviceMemoryBudgetPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -34086,19 +39405,24 @@ pub struct PhysicalDeviceMemoryBudgetPropertiesEXT {
     pub heap_usage: [DeviceSize; MAX_MEMORY_HEAPS],
 }
 impl ::std::default::Default for PhysicalDeviceMemoryBudgetPropertiesEXT {
-    fn default() -> PhysicalDeviceMemoryBudgetPropertiesEXT {
-        PhysicalDeviceMemoryBudgetPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             heap_budget: unsafe { ::std::mem::zeroed() },
             heap_usage: unsafe { ::std::mem::zeroed() },
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMemoryBudgetPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
+}
 impl PhysicalDeviceMemoryBudgetPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
         PhysicalDeviceMemoryBudgetPropertiesEXTBuilder {
-            inner: PhysicalDeviceMemoryBudgetPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34125,10 +39449,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryBudgetPropertiesEXTBuilder
     }
 }
 impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn heap_budget(mut self, heap_budget: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self {
         self.inner.heap_budget = heap_budget;
         self
     }
+    #[inline]
     pub fn heap_usage(mut self, heap_usage: [DeviceSize; MAX_MEMORY_HEAPS]) -> Self {
         self.inner.heap_usage = heap_usage;
         self
@@ -34141,26 +39467,32 @@ impl<'a> PhysicalDeviceMemoryBudgetPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html>"]
 pub struct PhysicalDeviceMemoryPriorityFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub memory_priority: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceMemoryPriorityFeaturesEXT {
-    fn default() -> PhysicalDeviceMemoryPriorityFeaturesEXT {
-        PhysicalDeviceMemoryPriorityFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             memory_priority: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceMemoryPriorityFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT;
+}
 impl PhysicalDeviceMemoryPriorityFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
         PhysicalDeviceMemoryPriorityFeaturesEXTBuilder {
-            inner: PhysicalDeviceMemoryPriorityFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34186,6 +39518,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder
     }
 }
 impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn memory_priority(mut self, memory_priority: bool) -> Self {
         self.inner.memory_priority = memory_priority.into();
         self
@@ -34198,26 +39531,31 @@ impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryPriorityAllocateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryPriorityAllocateInfoEXT.html>"]
 pub struct MemoryPriorityAllocateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub priority: f32,
 }
 impl ::std::default::Default for MemoryPriorityAllocateInfoEXT {
-    fn default() -> MemoryPriorityAllocateInfoEXT {
-        MemoryPriorityAllocateInfoEXT {
-            s_type: StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             priority: f32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryPriorityAllocateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_PRIORITY_ALLOCATE_INFO_EXT;
+}
 impl MemoryPriorityAllocateInfoEXT {
     pub fn builder<'a>() -> MemoryPriorityAllocateInfoEXTBuilder<'a> {
         MemoryPriorityAllocateInfoEXTBuilder {
-            inner: MemoryPriorityAllocateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34241,6 +39579,7 @@ impl<'a> ::std::ops::DerefMut for MemoryPriorityAllocateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn priority(mut self, priority: f32) -> Self {
         self.inner.priority = priority;
         self
@@ -34253,26 +39592,32 @@ impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.html>"]
 pub struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub pageable_device_local_memory: Bool32,
 }
 impl ::std::default::Default for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
-    fn default() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
-        PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             pageable_device_local_memory: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT;
+}
 impl PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
         PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder {
-            inner: PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34304,6 +39649,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePageableDeviceLocalMemoryFeature
     }
 }
 impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn pageable_device_local_memory(mut self, pageable_device_local_memory: bool) -> Self {
         self.inner.pageable_device_local_memory = pageable_device_local_memory.into();
         self
@@ -34316,8 +39662,9 @@ impl<'a> PhysicalDevicePageableDeviceLocalMemoryFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html>"]
 pub struct PhysicalDeviceBufferDeviceAddressFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -34326,9 +39673,10 @@ pub struct PhysicalDeviceBufferDeviceAddressFeatures {
     pub buffer_device_address_multi_device: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures {
-    fn default() -> PhysicalDeviceBufferDeviceAddressFeatures {
-        PhysicalDeviceBufferDeviceAddressFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             buffer_device_address: Bool32::default(),
             buffer_device_address_capture_replay: Bool32::default(),
@@ -34336,10 +39684,14 @@ impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeatures {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceBufferDeviceAddressFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
+}
 impl PhysicalDeviceBufferDeviceAddressFeatures {
     pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
         PhysicalDeviceBufferDeviceAddressFeaturesBuilder {
-            inner: PhysicalDeviceBufferDeviceAddressFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34368,10 +39720,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesBuild
     }
 }
 impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
+    #[inline]
     pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
         self.inner.buffer_device_address = buffer_device_address.into();
         self
     }
+    #[inline]
     pub fn buffer_device_address_capture_replay(
         mut self,
         buffer_device_address_capture_replay: bool,
@@ -34380,6 +39734,7 @@ impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
             buffer_device_address_capture_replay.into();
         self
     }
+    #[inline]
     pub fn buffer_device_address_multi_device(
         mut self,
         buffer_device_address_multi_device: bool,
@@ -34395,8 +39750,9 @@ impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html>"]
 pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -34405,9 +39761,10 @@ pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXT {
     pub buffer_device_address_multi_device: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
-    fn default() -> PhysicalDeviceBufferDeviceAddressFeaturesEXT {
-        PhysicalDeviceBufferDeviceAddressFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             buffer_device_address: Bool32::default(),
             buffer_device_address_capture_replay: Bool32::default(),
@@ -34415,10 +39772,14 @@ impl ::std::default::Default for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceBufferDeviceAddressFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
+}
 impl PhysicalDeviceBufferDeviceAddressFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
         PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder {
-            inner: PhysicalDeviceBufferDeviceAddressFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34447,10 +39808,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceBufferDeviceAddressFeaturesEXTBu
     }
 }
 impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
         self.inner.buffer_device_address = buffer_device_address.into();
         self
     }
+    #[inline]
     pub fn buffer_device_address_capture_replay(
         mut self,
         buffer_device_address_capture_replay: bool,
@@ -34459,6 +39822,7 @@ impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
             buffer_device_address_capture_replay.into();
         self
     }
+    #[inline]
     pub fn buffer_device_address_multi_device(
         mut self,
         buffer_device_address_multi_device: bool,
@@ -34474,26 +39838,31 @@ impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferDeviceAddressInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressInfo.html>"]
 pub struct BufferDeviceAddressInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub buffer: Buffer,
 }
 impl ::std::default::Default for BufferDeviceAddressInfo {
-    fn default() -> BufferDeviceAddressInfo {
-        BufferDeviceAddressInfo {
-            s_type: StructureType::BUFFER_DEVICE_ADDRESS_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             buffer: Buffer::default(),
         }
     }
 }
+unsafe impl TaggedStructure for BufferDeviceAddressInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_DEVICE_ADDRESS_INFO;
+}
 impl BufferDeviceAddressInfo {
     pub fn builder<'a>() -> BufferDeviceAddressInfoBuilder<'a> {
         BufferDeviceAddressInfoBuilder {
-            inner: BufferDeviceAddressInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34515,6 +39884,7 @@ impl<'a> ::std::ops::DerefMut for BufferDeviceAddressInfoBuilder<'a> {
     }
 }
 impl<'a> BufferDeviceAddressInfoBuilder<'a> {
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
@@ -34527,26 +39897,31 @@ impl<'a> BufferDeviceAddressInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html>"]
 pub struct BufferOpaqueCaptureAddressCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub opaque_capture_address: u64,
 }
 impl ::std::default::Default for BufferOpaqueCaptureAddressCreateInfo {
-    fn default() -> BufferOpaqueCaptureAddressCreateInfo {
-        BufferOpaqueCaptureAddressCreateInfo {
-            s_type: StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             opaque_capture_address: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for BufferOpaqueCaptureAddressCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
+}
 impl BufferOpaqueCaptureAddressCreateInfo {
     pub fn builder<'a>() -> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
         BufferOpaqueCaptureAddressCreateInfoBuilder {
-            inner: BufferOpaqueCaptureAddressCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34570,6 +39945,7 @@ impl<'a> ::std::ops::DerefMut for BufferOpaqueCaptureAddressCreateInfoBuilder<'a
     }
 }
 impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
+    #[inline]
     pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
         self.inner.opaque_capture_address = opaque_capture_address;
         self
@@ -34582,26 +39958,31 @@ impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferDeviceAddressCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferDeviceAddressCreateInfoEXT.html>"]
 pub struct BufferDeviceAddressCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub device_address: DeviceAddress,
 }
 impl ::std::default::Default for BufferDeviceAddressCreateInfoEXT {
-    fn default() -> BufferDeviceAddressCreateInfoEXT {
-        BufferDeviceAddressCreateInfoEXT {
-            s_type: StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             device_address: DeviceAddress::default(),
         }
     }
 }
+unsafe impl TaggedStructure for BufferDeviceAddressCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT;
+}
 impl BufferDeviceAddressCreateInfoEXT {
     pub fn builder<'a>() -> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
         BufferDeviceAddressCreateInfoEXTBuilder {
-            inner: BufferDeviceAddressCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34625,6 +40006,7 @@ impl<'a> ::std::ops::DerefMut for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
         self.inner.device_address = device_address;
         self
@@ -34637,26 +40019,32 @@ impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html>"]
 pub struct PhysicalDeviceImageViewImageFormatInfoEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub image_view_type: ImageViewType,
 }
 impl ::std::default::Default for PhysicalDeviceImageViewImageFormatInfoEXT {
-    fn default() -> PhysicalDeviceImageViewImageFormatInfoEXT {
-        PhysicalDeviceImageViewImageFormatInfoEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             image_view_type: ImageViewType::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceImageViewImageFormatInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT;
+}
 impl PhysicalDeviceImageViewImageFormatInfoEXT {
     pub fn builder<'a>() -> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
         PhysicalDeviceImageViewImageFormatInfoEXTBuilder {
-            inner: PhysicalDeviceImageViewImageFormatInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34683,6 +40071,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewImageFormatInfoEXTBuild
     }
 }
 impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
+    #[inline]
     pub fn image_view_type(mut self, image_view_type: ImageViewType) -> Self {
         self.inner.image_view_type = image_view_type;
         self
@@ -34695,8 +40084,9 @@ impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html>"]
 pub struct FilterCubicImageViewImageFormatPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -34704,19 +40094,24 @@ pub struct FilterCubicImageViewImageFormatPropertiesEXT {
     pub filter_cubic_minmax: Bool32,
 }
 impl ::std::default::Default for FilterCubicImageViewImageFormatPropertiesEXT {
-    fn default() -> FilterCubicImageViewImageFormatPropertiesEXT {
-        FilterCubicImageViewImageFormatPropertiesEXT {
-            s_type: StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             filter_cubic: Bool32::default(),
             filter_cubic_minmax: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for FilterCubicImageViewImageFormatPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT;
+}
 impl FilterCubicImageViewImageFormatPropertiesEXT {
     pub fn builder<'a>() -> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
         FilterCubicImageViewImageFormatPropertiesEXTBuilder {
-            inner: FilterCubicImageViewImageFormatPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34743,10 +40138,12 @@ impl<'a> ::std::ops::DerefMut for FilterCubicImageViewImageFormatPropertiesEXTBu
     }
 }
 impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn filter_cubic(mut self, filter_cubic: bool) -> Self {
         self.inner.filter_cubic = filter_cubic.into();
         self
     }
+    #[inline]
     pub fn filter_cubic_minmax(mut self, filter_cubic_minmax: bool) -> Self {
         self.inner.filter_cubic_minmax = filter_cubic_minmax.into();
         self
@@ -34759,26 +40156,32 @@ impl<'a> FilterCubicImageViewImageFormatPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html>"]
 pub struct PhysicalDeviceImagelessFramebufferFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub imageless_framebuffer: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceImagelessFramebufferFeatures {
-    fn default() -> PhysicalDeviceImagelessFramebufferFeatures {
-        PhysicalDeviceImagelessFramebufferFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             imageless_framebuffer: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceImagelessFramebufferFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
+}
 impl PhysicalDeviceImagelessFramebufferFeatures {
     pub fn builder<'a>() -> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
         PhysicalDeviceImagelessFramebufferFeaturesBuilder {
-            inner: PhysicalDeviceImagelessFramebufferFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34807,6 +40210,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceImagelessFramebufferFeaturesBuil
     }
 }
 impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
+    #[inline]
     pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
         self.inner.imageless_framebuffer = imageless_framebuffer.into();
         self
@@ -34819,8 +40223,9 @@ impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferAttachmentsCreateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentsCreateInfo.html>"]
 pub struct FramebufferAttachmentsCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -34828,19 +40233,23 @@ pub struct FramebufferAttachmentsCreateInfo {
     pub p_attachment_image_infos: *const FramebufferAttachmentImageInfo,
 }
 impl ::std::default::Default for FramebufferAttachmentsCreateInfo {
-    fn default() -> FramebufferAttachmentsCreateInfo {
-        FramebufferAttachmentsCreateInfo {
-            s_type: StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             attachment_image_info_count: u32::default(),
             p_attachment_image_infos: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for FramebufferAttachmentsCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
+}
 impl FramebufferAttachmentsCreateInfo {
     pub fn builder<'a>() -> FramebufferAttachmentsCreateInfoBuilder<'a> {
         FramebufferAttachmentsCreateInfoBuilder {
-            inner: FramebufferAttachmentsCreateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34864,6 +40273,7 @@ impl<'a> ::std::ops::DerefMut for FramebufferAttachmentsCreateInfoBuilder<'a> {
     }
 }
 impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> {
+    #[inline]
     pub fn attachment_image_infos(
         mut self,
         attachment_image_infos: &'a [FramebufferAttachmentImageInfo],
@@ -34880,8 +40290,9 @@ impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferAttachmentImageInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferAttachmentImageInfo.html>"]
 pub struct FramebufferAttachmentImageInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -34894,9 +40305,10 @@ pub struct FramebufferAttachmentImageInfo {
     pub p_view_formats: *const Format,
 }
 impl ::std::default::Default for FramebufferAttachmentImageInfo {
-    fn default() -> FramebufferAttachmentImageInfo {
-        FramebufferAttachmentImageInfo {
-            s_type: StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: ImageCreateFlags::default(),
             usage: ImageUsageFlags::default(),
@@ -34908,10 +40320,13 @@ impl ::std::default::Default for FramebufferAttachmentImageInfo {
         }
     }
 }
+unsafe impl TaggedStructure for FramebufferAttachmentImageInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
+}
 impl FramebufferAttachmentImageInfo {
     pub fn builder<'a>() -> FramebufferAttachmentImageInfoBuilder<'a> {
         FramebufferAttachmentImageInfoBuilder {
-            inner: FramebufferAttachmentImageInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -34933,26 +40348,32 @@ impl<'a> ::std::ops::DerefMut for FramebufferAttachmentImageInfoBuilder<'a> {
     }
 }
 impl<'a> FramebufferAttachmentImageInfoBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: ImageCreateFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn usage(mut self, usage: ImageUsageFlags) -> Self {
         self.inner.usage = usage;
         self
     }
+    #[inline]
     pub fn width(mut self, width: u32) -> Self {
         self.inner.width = width;
         self
     }
+    #[inline]
     pub fn height(mut self, height: u32) -> Self {
         self.inner.height = height;
         self
     }
+    #[inline]
     pub fn layer_count(mut self, layer_count: u32) -> Self {
         self.inner.layer_count = layer_count;
         self
     }
+    #[inline]
     pub fn view_formats(mut self, view_formats: &'a [Format]) -> Self {
         self.inner.view_format_count = view_formats.len() as _;
         self.inner.p_view_formats = view_formats.as_ptr();
@@ -34966,8 +40387,9 @@ impl<'a> FramebufferAttachmentImageInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassAttachmentBeginInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassAttachmentBeginInfo.html>"]
 pub struct RenderPassAttachmentBeginInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -34975,19 +40397,23 @@ pub struct RenderPassAttachmentBeginInfo {
     pub p_attachments: *const ImageView,
 }
 impl ::std::default::Default for RenderPassAttachmentBeginInfo {
-    fn default() -> RenderPassAttachmentBeginInfo {
-        RenderPassAttachmentBeginInfo {
-            s_type: StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             attachment_count: u32::default(),
             p_attachments: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for RenderPassAttachmentBeginInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_ATTACHMENT_BEGIN_INFO;
+}
 impl RenderPassAttachmentBeginInfo {
     pub fn builder<'a>() -> RenderPassAttachmentBeginInfoBuilder<'a> {
         RenderPassAttachmentBeginInfoBuilder {
-            inner: RenderPassAttachmentBeginInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35011,6 +40437,7 @@ impl<'a> ::std::ops::DerefMut for RenderPassAttachmentBeginInfoBuilder<'a> {
     }
 }
 impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> {
+    #[inline]
     pub fn attachments(mut self, attachments: &'a [ImageView]) -> Self {
         self.inner.attachment_count = attachments.len() as _;
         self.inner.p_attachments = attachments.as_ptr();
@@ -35024,57 +40451,61 @@ impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT.html>"]
-pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.html>"]
+pub struct PhysicalDeviceTextureCompressionASTCHDRFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub texture_compression_astc_hdr: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
-    fn default() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
-        PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT,
+impl ::std::default::Default for PhysicalDeviceTextureCompressionASTCHDRFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             texture_compression_astc_hdr: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
-        PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder {
-            inner: PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceTextureCompressionASTCHDRFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
+}
+impl PhysicalDeviceTextureCompressionASTCHDRFeatures {
+    pub fn builder<'a>() -> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
+        PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
-    inner: PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT,
+pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
+    inner: PhysicalDeviceTextureCompressionASTCHDRFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'_>
-{
-}
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {}
-unsafe impl ExtendsDeviceCreateInfo
-    for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'_>
+    for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_>
 {
 }
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
-    type Target = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTextureCompressionASTCHDRFeatures {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTextureCompressionASTCHDRFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
+    type Target = PhysicalDeviceTextureCompressionASTCHDRFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesBuilder<'a> {
+    #[inline]
     pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self {
         self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
         self
@@ -35082,13 +40513,14 @@ impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
+    pub fn build(self) -> PhysicalDeviceTextureCompressionASTCHDRFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html>"]
 pub struct PhysicalDeviceCooperativeMatrixFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -35096,19 +40528,24 @@ pub struct PhysicalDeviceCooperativeMatrixFeaturesNV {
     pub cooperative_matrix_robust_buffer_access: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceCooperativeMatrixFeaturesNV {
-    fn default() -> PhysicalDeviceCooperativeMatrixFeaturesNV {
-        PhysicalDeviceCooperativeMatrixFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             cooperative_matrix: Bool32::default(),
             cooperative_matrix_robust_buffer_access: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceCooperativeMatrixFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV;
+}
 impl PhysicalDeviceCooperativeMatrixFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
         PhysicalDeviceCooperativeMatrixFeaturesNVBuilder {
-            inner: PhysicalDeviceCooperativeMatrixFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35137,10 +40574,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixFeaturesNVBuild
     }
 }
 impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self {
         self.inner.cooperative_matrix = cooperative_matrix.into();
         self
     }
+    #[inline]
     pub fn cooperative_matrix_robust_buffer_access(
         mut self,
         cooperative_matrix_robust_buffer_access: bool,
@@ -35157,26 +40596,32 @@ impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html>"]
 pub struct PhysicalDeviceCooperativeMatrixPropertiesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub cooperative_matrix_supported_stages: ShaderStageFlags,
 }
 impl ::std::default::Default for PhysicalDeviceCooperativeMatrixPropertiesNV {
-    fn default() -> PhysicalDeviceCooperativeMatrixPropertiesNV {
-        PhysicalDeviceCooperativeMatrixPropertiesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             cooperative_matrix_supported_stages: ShaderStageFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceCooperativeMatrixPropertiesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV;
+}
 impl PhysicalDeviceCooperativeMatrixPropertiesNV {
     pub fn builder<'a>() -> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
         PhysicalDeviceCooperativeMatrixPropertiesNVBuilder {
-            inner: PhysicalDeviceCooperativeMatrixPropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35203,6 +40648,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceCooperativeMatrixPropertiesNVBui
     }
 }
 impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
+    #[inline]
     pub fn cooperative_matrix_supported_stages(
         mut self,
         cooperative_matrix_supported_stages: ShaderStageFlags,
@@ -35218,8 +40664,9 @@ impl<'a> PhysicalDeviceCooperativeMatrixPropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCooperativeMatrixPropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCooperativeMatrixPropertiesNV.html>"]
 pub struct CooperativeMatrixPropertiesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -35233,9 +40680,10 @@ pub struct CooperativeMatrixPropertiesNV {
     pub scope: ScopeNV,
 }
 impl ::std::default::Default for CooperativeMatrixPropertiesNV {
-    fn default() -> CooperativeMatrixPropertiesNV {
-        CooperativeMatrixPropertiesNV {
-            s_type: StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             m_size: u32::default(),
             n_size: u32::default(),
@@ -35248,10 +40696,13 @@ impl ::std::default::Default for CooperativeMatrixPropertiesNV {
         }
     }
 }
+unsafe impl TaggedStructure for CooperativeMatrixPropertiesNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::COOPERATIVE_MATRIX_PROPERTIES_NV;
+}
 impl CooperativeMatrixPropertiesNV {
     pub fn builder<'a>() -> CooperativeMatrixPropertiesNVBuilder<'a> {
         CooperativeMatrixPropertiesNVBuilder {
-            inner: CooperativeMatrixPropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35273,34 +40724,42 @@ impl<'a> ::std::ops::DerefMut for CooperativeMatrixPropertiesNVBuilder<'a> {
     }
 }
 impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> {
+    #[inline]
     pub fn m_size(mut self, m_size: u32) -> Self {
         self.inner.m_size = m_size;
         self
     }
+    #[inline]
     pub fn n_size(mut self, n_size: u32) -> Self {
         self.inner.n_size = n_size;
         self
     }
+    #[inline]
     pub fn k_size(mut self, k_size: u32) -> Self {
         self.inner.k_size = k_size;
         self
     }
+    #[inline]
     pub fn a_type(mut self, a_type: ComponentTypeNV) -> Self {
         self.inner.a_type = a_type;
         self
     }
+    #[inline]
     pub fn b_type(mut self, b_type: ComponentTypeNV) -> Self {
         self.inner.b_type = b_type;
         self
     }
+    #[inline]
     pub fn c_type(mut self, c_type: ComponentTypeNV) -> Self {
         self.inner.c_type = c_type;
         self
     }
+    #[inline]
     pub fn d_type(mut self, d_type: ComponentTypeNV) -> Self {
         self.inner.d_type = d_type;
         self
     }
+    #[inline]
     pub fn scope(mut self, scope: ScopeNV) -> Self {
         self.inner.scope = scope;
         self
@@ -35313,26 +40772,32 @@ impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html>"]
 pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub ycbcr_image_arrays: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceYcbcrImageArraysFeaturesEXT {
-    fn default() -> PhysicalDeviceYcbcrImageArraysFeaturesEXT {
-        PhysicalDeviceYcbcrImageArraysFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             ycbcr_image_arrays: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceYcbcrImageArraysFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT;
+}
 impl PhysicalDeviceYcbcrImageArraysFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
         PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder {
-            inner: PhysicalDeviceYcbcrImageArraysFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35361,6 +40826,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuild
     }
 }
 impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self {
         self.inner.ycbcr_image_arrays = ycbcr_image_arrays.into();
         self
@@ -35373,8 +40839,9 @@ impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewHandleInfoNVX.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewHandleInfoNVX.html>"]
 pub struct ImageViewHandleInfoNVX {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -35383,9 +40850,10 @@ pub struct ImageViewHandleInfoNVX {
     pub sampler: Sampler,
 }
 impl ::std::default::Default for ImageViewHandleInfoNVX {
-    fn default() -> ImageViewHandleInfoNVX {
-        ImageViewHandleInfoNVX {
-            s_type: StructureType::IMAGE_VIEW_HANDLE_INFO_NVX,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             image_view: ImageView::default(),
             descriptor_type: DescriptorType::default(),
@@ -35393,10 +40861,13 @@ impl ::std::default::Default for ImageViewHandleInfoNVX {
         }
     }
 }
+unsafe impl TaggedStructure for ImageViewHandleInfoNVX {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_HANDLE_INFO_NVX;
+}
 impl ImageViewHandleInfoNVX {
     pub fn builder<'a>() -> ImageViewHandleInfoNVXBuilder<'a> {
         ImageViewHandleInfoNVXBuilder {
-            inner: ImageViewHandleInfoNVX::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35418,14 +40889,17 @@ impl<'a> ::std::ops::DerefMut for ImageViewHandleInfoNVXBuilder<'a> {
     }
 }
 impl<'a> ImageViewHandleInfoNVXBuilder<'a> {
+    #[inline]
     pub fn image_view(mut self, image_view: ImageView) -> Self {
         self.inner.image_view = image_view;
         self
     }
+    #[inline]
     pub fn descriptor_type(mut self, descriptor_type: DescriptorType) -> Self {
         self.inner.descriptor_type = descriptor_type;
         self
     }
+    #[inline]
     pub fn sampler(mut self, sampler: Sampler) -> Self {
         self.inner.sampler = sampler;
         self
@@ -35438,8 +40912,9 @@ impl<'a> ImageViewHandleInfoNVXBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewAddressPropertiesNVX.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewAddressPropertiesNVX.html>"]
 pub struct ImageViewAddressPropertiesNVX {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -35447,19 +40922,23 @@ pub struct ImageViewAddressPropertiesNVX {
     pub size: DeviceSize,
 }
 impl ::std::default::Default for ImageViewAddressPropertiesNVX {
-    fn default() -> ImageViewAddressPropertiesNVX {
-        ImageViewAddressPropertiesNVX {
-            s_type: StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             device_address: DeviceAddress::default(),
             size: DeviceSize::default(),
         }
     }
 }
+unsafe impl TaggedStructure for ImageViewAddressPropertiesNVX {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_ADDRESS_PROPERTIES_NVX;
+}
 impl ImageViewAddressPropertiesNVX {
     pub fn builder<'a>() -> ImageViewAddressPropertiesNVXBuilder<'a> {
         ImageViewAddressPropertiesNVXBuilder {
-            inner: ImageViewAddressPropertiesNVX::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35481,10 +40960,12 @@ impl<'a> ::std::ops::DerefMut for ImageViewAddressPropertiesNVXBuilder<'a> {
     }
 }
 impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> {
+    #[inline]
     pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
         self.inner.device_address = device_address;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
@@ -35497,26 +40978,31 @@ impl<'a> ImageViewAddressPropertiesNVXBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentFrameTokenGGP.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentFrameTokenGGP.html>"]
 pub struct PresentFrameTokenGGP {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub frame_token: GgpFrameToken,
 }
 impl ::std::default::Default for PresentFrameTokenGGP {
-    fn default() -> PresentFrameTokenGGP {
-        PresentFrameTokenGGP {
-            s_type: StructureType::PRESENT_FRAME_TOKEN_GGP,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             frame_token: GgpFrameToken::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PresentFrameTokenGGP {
+    const STRUCTURE_TYPE: StructureType = StructureType::PRESENT_FRAME_TOKEN_GGP;
+}
 impl PresentFrameTokenGGP {
     pub fn builder<'a>() -> PresentFrameTokenGGPBuilder<'a> {
         PresentFrameTokenGGPBuilder {
-            inner: PresentFrameTokenGGP::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35540,6 +41026,7 @@ impl<'a> ::std::ops::DerefMut for PresentFrameTokenGGPBuilder<'a> {
     }
 }
 impl<'a> PresentFrameTokenGGPBuilder<'a> {
+    #[inline]
     pub fn frame_token(mut self, frame_token: GgpFrameToken) -> Self {
         self.inner.frame_token = frame_token;
         self
@@ -35552,41 +41039,44 @@ impl<'a> PresentFrameTokenGGPBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackEXT.html>"]
-pub struct PipelineCreationFeedbackEXT {
-    pub flags: PipelineCreationFeedbackFlagsEXT,
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedback.html>"]
+pub struct PipelineCreationFeedback {
+    pub flags: PipelineCreationFeedbackFlags,
     pub duration: u64,
 }
-impl PipelineCreationFeedbackEXT {
-    pub fn builder<'a>() -> PipelineCreationFeedbackEXTBuilder<'a> {
-        PipelineCreationFeedbackEXTBuilder {
-            inner: PipelineCreationFeedbackEXT::default(),
+impl PipelineCreationFeedback {
+    pub fn builder<'a>() -> PipelineCreationFeedbackBuilder<'a> {
+        PipelineCreationFeedbackBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PipelineCreationFeedbackEXTBuilder<'a> {
-    inner: PipelineCreationFeedbackEXT,
+pub struct PipelineCreationFeedbackBuilder<'a> {
+    inner: PipelineCreationFeedback,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for PipelineCreationFeedbackEXTBuilder<'a> {
-    type Target = PipelineCreationFeedbackEXT;
+impl<'a> ::std::ops::Deref for PipelineCreationFeedbackBuilder<'a> {
+    type Target = PipelineCreationFeedback;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PipelineCreationFeedbackEXTBuilder<'a> {
-    pub fn flags(mut self, flags: PipelineCreationFeedbackFlagsEXT) -> Self {
+impl<'a> PipelineCreationFeedbackBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: PipelineCreationFeedbackFlags) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn duration(mut self, duration: u64) -> Self {
         self.inner.duration = duration;
         self
@@ -35594,24 +41084,26 @@ impl<'a> PipelineCreationFeedbackEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PipelineCreationFeedbackEXT {
+    pub fn build(self) -> PipelineCreationFeedback {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCreationFeedbackCreateInfoEXT.html>"]
-pub struct PipelineCreationFeedbackCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCreationFeedbackCreateInfo.html>"]
+pub struct PipelineCreationFeedbackCreateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub p_pipeline_creation_feedback: *mut PipelineCreationFeedbackEXT,
+    pub p_pipeline_creation_feedback: *mut PipelineCreationFeedback,
     pub pipeline_stage_creation_feedback_count: u32,
-    pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedbackEXT,
+    pub p_pipeline_stage_creation_feedbacks: *mut PipelineCreationFeedback,
 }
-impl ::std::default::Default for PipelineCreationFeedbackCreateInfoEXT {
-    fn default() -> PipelineCreationFeedbackCreateInfoEXT {
-        PipelineCreationFeedbackCreateInfoEXT {
-            s_type: StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT,
+impl ::std::default::Default for PipelineCreationFeedbackCreateInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_pipeline_creation_feedback: ::std::ptr::null_mut(),
             pipeline_stage_creation_feedback_count: u32::default(),
@@ -35619,55 +41111,60 @@ impl ::std::default::Default for PipelineCreationFeedbackCreateInfoEXT {
         }
     }
 }
-impl PipelineCreationFeedbackCreateInfoEXT {
-    pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
-        PipelineCreationFeedbackCreateInfoEXTBuilder {
-            inner: PipelineCreationFeedbackCreateInfoEXT::default(),
+unsafe impl TaggedStructure for PipelineCreationFeedbackCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
+}
+impl PipelineCreationFeedbackCreateInfo {
+    pub fn builder<'a>() -> PipelineCreationFeedbackCreateInfoBuilder<'a> {
+        PipelineCreationFeedbackCreateInfoBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
-    inner: PipelineCreationFeedbackCreateInfoEXT,
+pub struct PipelineCreationFeedbackCreateInfoBuilder<'a> {
+    inner: PipelineCreationFeedbackCreateInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXTBuilder<'_> {}
-unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXT {}
-unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXTBuilder<'_> {}
-unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoEXT {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineCreationFeedbackCreateInfo {}
+unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfoBuilder<'_> {}
+unsafe impl ExtendsComputePipelineCreateInfo for PipelineCreationFeedbackCreateInfo {}
 unsafe impl ExtendsRayTracingPipelineCreateInfoNV
-    for PipelineCreationFeedbackCreateInfoEXTBuilder<'_>
+    for PipelineCreationFeedbackCreateInfoBuilder<'_>
 {
 }
-unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfoEXT {}
+unsafe impl ExtendsRayTracingPipelineCreateInfoNV for PipelineCreationFeedbackCreateInfo {}
 unsafe impl ExtendsRayTracingPipelineCreateInfoKHR
-    for PipelineCreationFeedbackCreateInfoEXTBuilder<'_>
+    for PipelineCreationFeedbackCreateInfoBuilder<'_>
 {
 }
-unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfoEXT {}
-impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
-    type Target = PipelineCreationFeedbackCreateInfoEXT;
+unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineCreationFeedbackCreateInfo {}
+impl<'a> ::std::ops::Deref for PipelineCreationFeedbackCreateInfoBuilder<'a> {
+    type Target = PipelineCreationFeedbackCreateInfo;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PipelineCreationFeedbackCreateInfoBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
+impl<'a> PipelineCreationFeedbackCreateInfoBuilder<'a> {
+    #[inline]
     pub fn pipeline_creation_feedback(
         mut self,
-        pipeline_creation_feedback: &'a mut PipelineCreationFeedbackEXT,
+        pipeline_creation_feedback: &'a mut PipelineCreationFeedback,
     ) -> Self {
         self.inner.p_pipeline_creation_feedback = pipeline_creation_feedback;
         self
     }
+    #[inline]
     pub fn pipeline_stage_creation_feedbacks(
         mut self,
-        pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedbackEXT],
+        pipeline_stage_creation_feedbacks: &'a mut [PipelineCreationFeedback],
     ) -> Self {
         self.inner.pipeline_stage_creation_feedback_count =
             pipeline_stage_creation_feedbacks.len() as _;
@@ -35678,31 +41175,36 @@ impl<'a> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PipelineCreationFeedbackCreateInfoEXT {
+    pub fn build(self) -> PipelineCreationFeedbackCreateInfo {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html>"]
 pub struct SurfaceFullScreenExclusiveInfoEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub full_screen_exclusive: FullScreenExclusiveEXT,
 }
 impl ::std::default::Default for SurfaceFullScreenExclusiveInfoEXT {
-    fn default() -> SurfaceFullScreenExclusiveInfoEXT {
-        SurfaceFullScreenExclusiveInfoEXT {
-            s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             full_screen_exclusive: FullScreenExclusiveEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SurfaceFullScreenExclusiveInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT;
+}
 impl SurfaceFullScreenExclusiveInfoEXT {
     pub fn builder<'a>() -> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
         SurfaceFullScreenExclusiveInfoEXTBuilder {
-            inner: SurfaceFullScreenExclusiveInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35728,6 +41230,7 @@ impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
     }
 }
 impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
+    #[inline]
     pub fn full_screen_exclusive(mut self, full_screen_exclusive: FullScreenExclusiveEXT) -> Self {
         self.inner.full_screen_exclusive = full_screen_exclusive;
         self
@@ -35740,26 +41243,32 @@ impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html>"]
 pub struct SurfaceFullScreenExclusiveWin32InfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub hmonitor: HMONITOR,
 }
 impl ::std::default::Default for SurfaceFullScreenExclusiveWin32InfoEXT {
-    fn default() -> SurfaceFullScreenExclusiveWin32InfoEXT {
-        SurfaceFullScreenExclusiveWin32InfoEXT {
-            s_type: StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             hmonitor: unsafe { ::std::mem::zeroed() },
         }
     }
 }
+unsafe impl TaggedStructure for SurfaceFullScreenExclusiveWin32InfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT;
+}
 impl SurfaceFullScreenExclusiveWin32InfoEXT {
     pub fn builder<'a>() -> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
         SurfaceFullScreenExclusiveWin32InfoEXTBuilder {
-            inner: SurfaceFullScreenExclusiveWin32InfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35788,6 +41297,7 @@ impl<'a> ::std::ops::DerefMut for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<
     }
 }
 impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
+    #[inline]
     pub fn hmonitor(mut self, hmonitor: HMONITOR) -> Self {
         self.inner.hmonitor = hmonitor;
         self
@@ -35800,26 +41310,32 @@ impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html>"]
 pub struct SurfaceCapabilitiesFullScreenExclusiveEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub full_screen_exclusive_supported: Bool32,
 }
 impl ::std::default::Default for SurfaceCapabilitiesFullScreenExclusiveEXT {
-    fn default() -> SurfaceCapabilitiesFullScreenExclusiveEXT {
-        SurfaceCapabilitiesFullScreenExclusiveEXT {
-            s_type: StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             full_screen_exclusive_supported: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SurfaceCapabilitiesFullScreenExclusiveEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT;
+}
 impl SurfaceCapabilitiesFullScreenExclusiveEXT {
     pub fn builder<'a>() -> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
         SurfaceCapabilitiesFullScreenExclusiveEXTBuilder {
-            inner: SurfaceCapabilitiesFullScreenExclusiveEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35846,6 +41362,7 @@ impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesFullScreenExclusiveEXTBuild
     }
 }
 impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
+    #[inline]
     pub fn full_screen_exclusive_supported(
         mut self,
         full_screen_exclusive_supported: bool,
@@ -35861,8 +41378,195 @@ impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePresentBarrierFeaturesNV.html>"]
+pub struct PhysicalDevicePresentBarrierFeaturesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub present_barrier: Bool32,
+}
+impl ::std::default::Default for PhysicalDevicePresentBarrierFeaturesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            present_barrier: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDevicePresentBarrierFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV;
+}
+impl PhysicalDevicePresentBarrierFeaturesNV {
+    pub fn builder<'a>() -> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
+        PhysicalDevicePresentBarrierFeaturesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
+    inner: PhysicalDevicePresentBarrierFeaturesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNVBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNV {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNVBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
+    type Target = PhysicalDevicePresentBarrierFeaturesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDevicePresentBarrierFeaturesNVBuilder<'a> {
+    #[inline]
+    pub fn present_barrier(mut self, present_barrier: bool) -> Self {
+        self.inner.present_barrier = present_barrier.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDevicePresentBarrierFeaturesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesPresentBarrierNV.html>"]
+pub struct SurfaceCapabilitiesPresentBarrierNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub present_barrier_supported: Bool32,
+}
+impl ::std::default::Default for SurfaceCapabilitiesPresentBarrierNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            present_barrier_supported: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SurfaceCapabilitiesPresentBarrierNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV;
+}
+impl SurfaceCapabilitiesPresentBarrierNV {
+    pub fn builder<'a>() -> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
+        SurfaceCapabilitiesPresentBarrierNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
+    inner: SurfaceCapabilitiesPresentBarrierNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNVBuilder<'_> {}
+unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNV {}
+impl<'a> ::std::ops::Deref for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
+    type Target = SurfaceCapabilitiesPresentBarrierNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SurfaceCapabilitiesPresentBarrierNVBuilder<'a> {
+    #[inline]
+    pub fn present_barrier_supported(mut self, present_barrier_supported: bool) -> Self {
+        self.inner.present_barrier_supported = present_barrier_supported.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SurfaceCapabilitiesPresentBarrierNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentBarrierCreateInfoNV.html>"]
+pub struct SwapchainPresentBarrierCreateInfoNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub present_barrier_enable: Bool32,
+}
+impl ::std::default::Default for SwapchainPresentBarrierCreateInfoNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            present_barrier_enable: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SwapchainPresentBarrierCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV;
+}
+impl SwapchainPresentBarrierCreateInfoNV {
+    pub fn builder<'a>() -> SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
+        SwapchainPresentBarrierCreateInfoNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
+    inner: SwapchainPresentBarrierCreateInfoNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNVBuilder<'_> {}
+unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNV {}
+impl<'a> ::std::ops::Deref for SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
+    type Target = SwapchainPresentBarrierCreateInfoNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SwapchainPresentBarrierCreateInfoNVBuilder<'a> {
+    #[inline]
+    pub fn present_barrier_enable(mut self, present_barrier_enable: bool) -> Self {
+        self.inner.present_barrier_enable = present_barrier_enable.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SwapchainPresentBarrierCreateInfoNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html>"]
 pub struct PhysicalDevicePerformanceQueryFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -35870,19 +41574,24 @@ pub struct PhysicalDevicePerformanceQueryFeaturesKHR {
     pub performance_counter_multiple_query_pools: Bool32,
 }
 impl ::std::default::Default for PhysicalDevicePerformanceQueryFeaturesKHR {
-    fn default() -> PhysicalDevicePerformanceQueryFeaturesKHR {
-        PhysicalDevicePerformanceQueryFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             performance_counter_query_pools: Bool32::default(),
             performance_counter_multiple_query_pools: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePerformanceQueryFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR;
+}
 impl PhysicalDevicePerformanceQueryFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
         PhysicalDevicePerformanceQueryFeaturesKHRBuilder {
-            inner: PhysicalDevicePerformanceQueryFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35911,6 +41620,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryFeaturesKHRBuild
     }
 }
 impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn performance_counter_query_pools(
         mut self,
         performance_counter_query_pools: bool,
@@ -35918,6 +41628,7 @@ impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
         self.inner.performance_counter_query_pools = performance_counter_query_pools.into();
         self
     }
+    #[inline]
     pub fn performance_counter_multiple_query_pools(
         mut self,
         performance_counter_multiple_query_pools: bool,
@@ -35934,26 +41645,32 @@ impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html>"]
 pub struct PhysicalDevicePerformanceQueryPropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub allow_command_buffer_query_copies: Bool32,
 }
 impl ::std::default::Default for PhysicalDevicePerformanceQueryPropertiesKHR {
-    fn default() -> PhysicalDevicePerformanceQueryPropertiesKHR {
-        PhysicalDevicePerformanceQueryPropertiesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             allow_command_buffer_query_copies: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePerformanceQueryPropertiesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR;
+}
 impl PhysicalDevicePerformanceQueryPropertiesKHR {
     pub fn builder<'a>() -> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
         PhysicalDevicePerformanceQueryPropertiesKHRBuilder {
-            inner: PhysicalDevicePerformanceQueryPropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -35980,6 +41697,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePerformanceQueryPropertiesKHRBui
     }
 }
 impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn allow_command_buffer_query_copies(
         mut self,
         allow_command_buffer_query_copies: bool,
@@ -35995,8 +41713,9 @@ impl<'a> PhysicalDevicePerformanceQueryPropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterKHR.html>"]
 pub struct PerformanceCounterKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -36006,9 +41725,10 @@ pub struct PerformanceCounterKHR {
     pub uuid: [u8; UUID_SIZE],
 }
 impl ::std::default::Default for PerformanceCounterKHR {
-    fn default() -> PerformanceCounterKHR {
-        PerformanceCounterKHR {
-            s_type: StructureType::PERFORMANCE_COUNTER_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             unit: PerformanceCounterUnitKHR::default(),
             scope: PerformanceCounterScopeKHR::default(),
@@ -36017,10 +41737,13 @@ impl ::std::default::Default for PerformanceCounterKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PerformanceCounterKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_COUNTER_KHR;
+}
 impl PerformanceCounterKHR {
     pub fn builder<'a>() -> PerformanceCounterKHRBuilder<'a> {
         PerformanceCounterKHRBuilder {
-            inner: PerformanceCounterKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36042,18 +41765,22 @@ impl<'a> ::std::ops::DerefMut for PerformanceCounterKHRBuilder<'a> {
     }
 }
 impl<'a> PerformanceCounterKHRBuilder<'a> {
+    #[inline]
     pub fn unit(mut self, unit: PerformanceCounterUnitKHR) -> Self {
         self.inner.unit = unit;
         self
     }
+    #[inline]
     pub fn scope(mut self, scope: PerformanceCounterScopeKHR) -> Self {
         self.inner.scope = scope;
         self
     }
+    #[inline]
     pub fn storage(mut self, storage: PerformanceCounterStorageKHR) -> Self {
         self.inner.storage = storage;
         self
     }
+    #[inline]
     pub fn uuid(mut self, uuid: [u8; UUID_SIZE]) -> Self {
         self.inner.uuid = uuid;
         self
@@ -36067,7 +41794,7 @@ impl<'a> PerformanceCounterKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterDescriptionKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterDescriptionKHR.html>"]
 pub struct PerformanceCounterDescriptionKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -36076,6 +41803,7 @@ pub struct PerformanceCounterDescriptionKHR {
     pub category: [c_char; MAX_DESCRIPTION_SIZE],
     pub description: [c_char; MAX_DESCRIPTION_SIZE],
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for PerformanceCounterDescriptionKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("PerformanceCounterDescriptionKHR")
@@ -36083,21 +41811,22 @@ impl fmt::Debug for PerformanceCounterDescriptionKHR {
             .field("p_next", &self.p_next)
             .field("flags", &self.flags)
             .field("name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
             })
             .field("category", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.category.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.category.as_ptr())
             })
             .field("description", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
             })
             .finish()
     }
 }
 impl ::std::default::Default for PerformanceCounterDescriptionKHR {
-    fn default() -> PerformanceCounterDescriptionKHR {
-        PerformanceCounterDescriptionKHR {
-            s_type: StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             flags: PerformanceCounterDescriptionFlagsKHR::default(),
             name: unsafe { ::std::mem::zeroed() },
@@ -36106,10 +41835,13 @@ impl ::std::default::Default for PerformanceCounterDescriptionKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PerformanceCounterDescriptionKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_COUNTER_DESCRIPTION_KHR;
+}
 impl PerformanceCounterDescriptionKHR {
     pub fn builder<'a>() -> PerformanceCounterDescriptionKHRBuilder<'a> {
         PerformanceCounterDescriptionKHRBuilder {
-            inner: PerformanceCounterDescriptionKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36131,18 +41863,22 @@ impl<'a> ::std::ops::DerefMut for PerformanceCounterDescriptionKHRBuilder<'a> {
     }
 }
 impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PerformanceCounterDescriptionFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.name = name;
         self
     }
+    #[inline]
     pub fn category(mut self, category: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.category = category;
         self
     }
+    #[inline]
     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.description = description;
         self
@@ -36155,8 +41891,9 @@ impl<'a> PerformanceCounterDescriptionKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolPerformanceCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceCreateInfoKHR.html>"]
 pub struct QueryPoolPerformanceCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -36165,9 +41902,10 @@ pub struct QueryPoolPerformanceCreateInfoKHR {
     pub p_counter_indices: *const u32,
 }
 impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR {
-    fn default() -> QueryPoolPerformanceCreateInfoKHR {
-        QueryPoolPerformanceCreateInfoKHR {
-            s_type: StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             queue_family_index: u32::default(),
             counter_index_count: u32::default(),
@@ -36175,10 +41913,13 @@ impl ::std::default::Default for QueryPoolPerformanceCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for QueryPoolPerformanceCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR;
+}
 impl QueryPoolPerformanceCreateInfoKHR {
     pub fn builder<'a>() -> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
         QueryPoolPerformanceCreateInfoKHRBuilder {
-            inner: QueryPoolPerformanceCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36202,10 +41943,12 @@ impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
         self.inner.queue_family_index = queue_family_index;
         self
     }
+    #[inline]
     pub fn counter_indices(mut self, counter_indices: &'a [u32]) -> Self {
         self.inner.counter_index_count = counter_indices.len() as _;
         self.inner.p_counter_indices = counter_indices.as_ptr();
@@ -36220,7 +41963,7 @@ impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterResultKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterResultKHR.html>"]
 pub union PerformanceCounterResultKHR {
     pub int32: i32,
     pub int64: i64,
@@ -36230,13 +41973,15 @@ pub union PerformanceCounterResultKHR {
     pub float64: f64,
 }
 impl ::std::default::Default for PerformanceCounterResultKHR {
-    fn default() -> PerformanceCounterResultKHR {
+    #[inline]
+    fn default() -> Self {
         unsafe { ::std::mem::zeroed() }
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAcquireProfilingLockInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAcquireProfilingLockInfoKHR.html>"]
 pub struct AcquireProfilingLockInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -36244,19 +41989,23 @@ pub struct AcquireProfilingLockInfoKHR {
     pub timeout: u64,
 }
 impl ::std::default::Default for AcquireProfilingLockInfoKHR {
-    fn default() -> AcquireProfilingLockInfoKHR {
-        AcquireProfilingLockInfoKHR {
-            s_type: StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: AcquireProfilingLockFlagsKHR::default(),
             timeout: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AcquireProfilingLockInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::ACQUIRE_PROFILING_LOCK_INFO_KHR;
+}
 impl AcquireProfilingLockInfoKHR {
     pub fn builder<'a>() -> AcquireProfilingLockInfoKHRBuilder<'a> {
         AcquireProfilingLockInfoKHRBuilder {
-            inner: AcquireProfilingLockInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36278,10 +42027,12 @@ impl<'a> ::std::ops::DerefMut for AcquireProfilingLockInfoKHRBuilder<'a> {
     }
 }
 impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: AcquireProfilingLockFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn timeout(mut self, timeout: u64) -> Self {
         self.inner.timeout = timeout;
         self
@@ -36294,26 +42045,31 @@ impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceQuerySubmitInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceQuerySubmitInfoKHR.html>"]
 pub struct PerformanceQuerySubmitInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub counter_pass_index: u32,
 }
 impl ::std::default::Default for PerformanceQuerySubmitInfoKHR {
-    fn default() -> PerformanceQuerySubmitInfoKHR {
-        PerformanceQuerySubmitInfoKHR {
-            s_type: StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             counter_pass_index: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PerformanceQuerySubmitInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_QUERY_SUBMIT_INFO_KHR;
+}
 impl PerformanceQuerySubmitInfoKHR {
     pub fn builder<'a>() -> PerformanceQuerySubmitInfoKHRBuilder<'a> {
         PerformanceQuerySubmitInfoKHRBuilder {
-            inner: PerformanceQuerySubmitInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36325,8 +42081,8 @@ pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> {
 }
 unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
 unsafe impl ExtendsSubmitInfo for PerformanceQuerySubmitInfoKHR {}
-unsafe impl ExtendsSubmitInfo2KHR for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
-unsafe impl ExtendsSubmitInfo2KHR for PerformanceQuerySubmitInfoKHR {}
+unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHRBuilder<'_> {}
+unsafe impl ExtendsSubmitInfo2 for PerformanceQuerySubmitInfoKHR {}
 impl<'a> ::std::ops::Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> {
     type Target = PerformanceQuerySubmitInfoKHR;
     fn deref(&self) -> &Self::Target {
@@ -36339,6 +42095,7 @@ impl<'a> ::std::ops::DerefMut for PerformanceQuerySubmitInfoKHRBuilder<'a> {
     }
 }
 impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> {
+    #[inline]
     pub fn counter_pass_index(mut self, counter_pass_index: u32) -> Self {
         self.inner.counter_pass_index = counter_pass_index;
         self
@@ -36351,26 +42108,31 @@ impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkHeadlessSurfaceCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkHeadlessSurfaceCreateInfoEXT.html>"]
 pub struct HeadlessSurfaceCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: HeadlessSurfaceCreateFlagsEXT,
 }
 impl ::std::default::Default for HeadlessSurfaceCreateInfoEXT {
-    fn default() -> HeadlessSurfaceCreateInfoEXT {
-        HeadlessSurfaceCreateInfoEXT {
-            s_type: StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: HeadlessSurfaceCreateFlagsEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for HeadlessSurfaceCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::HEADLESS_SURFACE_CREATE_INFO_EXT;
+}
 impl HeadlessSurfaceCreateInfoEXT {
     pub fn builder<'a>() -> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
         HeadlessSurfaceCreateInfoEXTBuilder {
-            inner: HeadlessSurfaceCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36392,6 +42154,7 @@ impl<'a> ::std::ops::DerefMut for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: HeadlessSurfaceCreateFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
@@ -36404,26 +42167,32 @@ impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html>"]
 pub struct PhysicalDeviceCoverageReductionModeFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub coverage_reduction_mode: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceCoverageReductionModeFeaturesNV {
-    fn default() -> PhysicalDeviceCoverageReductionModeFeaturesNV {
-        PhysicalDeviceCoverageReductionModeFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             coverage_reduction_mode: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceCoverageReductionModeFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV;
+}
 impl PhysicalDeviceCoverageReductionModeFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
         PhysicalDeviceCoverageReductionModeFeaturesNVBuilder {
-            inner: PhysicalDeviceCoverageReductionModeFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36452,6 +42221,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoverageReductionModeFeaturesNVB
     }
 }
 impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self {
         self.inner.coverage_reduction_mode = coverage_reduction_mode.into();
         self
@@ -36464,8 +42234,9 @@ impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html>"]
 pub struct PipelineCoverageReductionStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -36473,19 +42244,24 @@ pub struct PipelineCoverageReductionStateCreateInfoNV {
     pub coverage_reduction_mode: CoverageReductionModeNV,
 }
 impl ::std::default::Default for PipelineCoverageReductionStateCreateInfoNV {
-    fn default() -> PipelineCoverageReductionStateCreateInfoNV {
-        PipelineCoverageReductionStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: PipelineCoverageReductionStateCreateFlagsNV::default(),
             coverage_reduction_mode: CoverageReductionModeNV::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineCoverageReductionStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV;
+}
 impl PipelineCoverageReductionStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
         PipelineCoverageReductionStateCreateInfoNVBuilder {
-            inner: PipelineCoverageReductionStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36515,10 +42291,12 @@ impl<'a> ::std::ops::DerefMut for PipelineCoverageReductionStateCreateInfoNVBuil
     }
 }
 impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: PipelineCoverageReductionStateCreateFlagsNV) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn coverage_reduction_mode(
         mut self,
         coverage_reduction_mode: CoverageReductionModeNV,
@@ -36534,8 +42312,9 @@ impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFramebufferMixedSamplesCombinationNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFramebufferMixedSamplesCombinationNV.html>"]
 pub struct FramebufferMixedSamplesCombinationNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -36545,9 +42324,10 @@ pub struct FramebufferMixedSamplesCombinationNV {
     pub color_samples: SampleCountFlags,
 }
 impl ::std::default::Default for FramebufferMixedSamplesCombinationNV {
-    fn default() -> FramebufferMixedSamplesCombinationNV {
-        FramebufferMixedSamplesCombinationNV {
-            s_type: StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             coverage_reduction_mode: CoverageReductionModeNV::default(),
             rasterization_samples: SampleCountFlags::default(),
@@ -36556,10 +42336,13 @@ impl ::std::default::Default for FramebufferMixedSamplesCombinationNV {
         }
     }
 }
+unsafe impl TaggedStructure for FramebufferMixedSamplesCombinationNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV;
+}
 impl FramebufferMixedSamplesCombinationNV {
     pub fn builder<'a>() -> FramebufferMixedSamplesCombinationNVBuilder<'a> {
         FramebufferMixedSamplesCombinationNVBuilder {
-            inner: FramebufferMixedSamplesCombinationNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36581,6 +42364,7 @@ impl<'a> ::std::ops::DerefMut for FramebufferMixedSamplesCombinationNVBuilder<'a
     }
 }
 impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> {
+    #[inline]
     pub fn coverage_reduction_mode(
         mut self,
         coverage_reduction_mode: CoverageReductionModeNV,
@@ -36588,14 +42372,17 @@ impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> {
         self.inner.coverage_reduction_mode = coverage_reduction_mode;
         self
     }
+    #[inline]
     pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
         self.inner.rasterization_samples = rasterization_samples;
         self
     }
+    #[inline]
     pub fn depth_stencil_samples(mut self, depth_stencil_samples: SampleCountFlags) -> Self {
         self.inner.depth_stencil_samples = depth_stencil_samples;
         self
     }
+    #[inline]
     pub fn color_samples(mut self, color_samples: SampleCountFlags) -> Self {
         self.inner.color_samples = color_samples;
         self
@@ -36608,26 +42395,32 @@ impl<'a> FramebufferMixedSamplesCombinationNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html>"]
 pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shader_integer_functions2: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
-    fn default() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
-        PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_integer_functions2: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
+}
 impl PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
     pub fn builder<'a>() -> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
         PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder {
-            inner: PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36659,6 +42452,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerFunctions2FeaturesI
     }
 }
 impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
+    #[inline]
     pub fn shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self {
         self.inner.shader_integer_functions2 = shader_integer_functions2.into();
         self
@@ -36672,7 +42466,7 @@ impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceValueDataINTEL.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueDataINTEL.html>"]
 pub union PerformanceValueDataINTEL {
     pub value32: u32,
     pub value64: u64,
@@ -36681,17 +42475,19 @@ pub union PerformanceValueDataINTEL {
     pub value_string: *const c_char,
 }
 impl ::std::default::Default for PerformanceValueDataINTEL {
-    fn default() -> PerformanceValueDataINTEL {
+    #[inline]
+    fn default() -> Self {
         unsafe { ::std::mem::zeroed() }
     }
 }
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceValueINTEL.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueINTEL.html>"]
 pub struct PerformanceValueINTEL {
     pub ty: PerformanceValueTypeINTEL,
     pub data: PerformanceValueDataINTEL,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for PerformanceValueINTEL {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("PerformanceValueINTEL")
@@ -36703,7 +42499,7 @@ impl fmt::Debug for PerformanceValueINTEL {
 impl PerformanceValueINTEL {
     pub fn builder<'a>() -> PerformanceValueINTELBuilder<'a> {
         PerformanceValueINTELBuilder {
-            inner: PerformanceValueINTEL::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36725,10 +42521,12 @@ impl<'a> ::std::ops::DerefMut for PerformanceValueINTELBuilder<'a> {
     }
 }
 impl<'a> PerformanceValueINTELBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: PerformanceValueTypeINTEL) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn data(mut self, data: PerformanceValueDataINTEL) -> Self {
         self.inner.data = data;
         self
@@ -36741,26 +42539,31 @@ impl<'a> PerformanceValueINTELBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInitializePerformanceApiInfoINTEL.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInitializePerformanceApiInfoINTEL.html>"]
 pub struct InitializePerformanceApiInfoINTEL {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub p_user_data: *mut c_void,
 }
 impl ::std::default::Default for InitializePerformanceApiInfoINTEL {
-    fn default() -> InitializePerformanceApiInfoINTEL {
-        InitializePerformanceApiInfoINTEL {
-            s_type: StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_user_data: ::std::ptr::null_mut(),
         }
     }
 }
+unsafe impl TaggedStructure for InitializePerformanceApiInfoINTEL {
+    const STRUCTURE_TYPE: StructureType = StructureType::INITIALIZE_PERFORMANCE_API_INFO_INTEL;
+}
 impl InitializePerformanceApiInfoINTEL {
     pub fn builder<'a>() -> InitializePerformanceApiInfoINTELBuilder<'a> {
         InitializePerformanceApiInfoINTELBuilder {
-            inner: InitializePerformanceApiInfoINTEL::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36782,6 +42585,7 @@ impl<'a> ::std::ops::DerefMut for InitializePerformanceApiInfoINTELBuilder<'a> {
     }
 }
 impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> {
+    #[inline]
     pub fn user_data(mut self, user_data: *mut c_void) -> Self {
         self.inner.p_user_data = user_data;
         self
@@ -36794,26 +42598,32 @@ impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html>"]
 pub struct QueryPoolPerformanceQueryCreateInfoINTEL {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub performance_counters_sampling: QueryPoolSamplingModeINTEL,
 }
 impl ::std::default::Default for QueryPoolPerformanceQueryCreateInfoINTEL {
-    fn default() -> QueryPoolPerformanceQueryCreateInfoINTEL {
-        QueryPoolPerformanceQueryCreateInfoINTEL {
-            s_type: StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             performance_counters_sampling: QueryPoolSamplingModeINTEL::default(),
         }
     }
 }
+unsafe impl TaggedStructure for QueryPoolPerformanceQueryCreateInfoINTEL {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
+}
 impl QueryPoolPerformanceQueryCreateInfoINTEL {
     pub fn builder<'a>() -> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
         QueryPoolPerformanceQueryCreateInfoINTELBuilder {
-            inner: QueryPoolPerformanceQueryCreateInfoINTEL::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36837,6 +42647,7 @@ impl<'a> ::std::ops::DerefMut for QueryPoolPerformanceQueryCreateInfoINTELBuilde
     }
 }
 impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
+    #[inline]
     pub fn performance_counters_sampling(
         mut self,
         performance_counters_sampling: QueryPoolSamplingModeINTEL,
@@ -36852,26 +42663,31 @@ impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceMarkerInfoINTEL.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceMarkerInfoINTEL.html>"]
 pub struct PerformanceMarkerInfoINTEL {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub marker: u64,
 }
 impl ::std::default::Default for PerformanceMarkerInfoINTEL {
-    fn default() -> PerformanceMarkerInfoINTEL {
-        PerformanceMarkerInfoINTEL {
-            s_type: StructureType::PERFORMANCE_MARKER_INFO_INTEL,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             marker: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PerformanceMarkerInfoINTEL {
+    const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_MARKER_INFO_INTEL;
+}
 impl PerformanceMarkerInfoINTEL {
     pub fn builder<'a>() -> PerformanceMarkerInfoINTELBuilder<'a> {
         PerformanceMarkerInfoINTELBuilder {
-            inner: PerformanceMarkerInfoINTEL::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36893,6 +42709,7 @@ impl<'a> ::std::ops::DerefMut for PerformanceMarkerInfoINTELBuilder<'a> {
     }
 }
 impl<'a> PerformanceMarkerInfoINTELBuilder<'a> {
+    #[inline]
     pub fn marker(mut self, marker: u64) -> Self {
         self.inner.marker = marker;
         self
@@ -36905,26 +42722,31 @@ impl<'a> PerformanceMarkerInfoINTELBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceStreamMarkerInfoINTEL.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceStreamMarkerInfoINTEL.html>"]
 pub struct PerformanceStreamMarkerInfoINTEL {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub marker: u32,
 }
 impl ::std::default::Default for PerformanceStreamMarkerInfoINTEL {
-    fn default() -> PerformanceStreamMarkerInfoINTEL {
-        PerformanceStreamMarkerInfoINTEL {
-            s_type: StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             marker: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PerformanceStreamMarkerInfoINTEL {
+    const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_STREAM_MARKER_INFO_INTEL;
+}
 impl PerformanceStreamMarkerInfoINTEL {
     pub fn builder<'a>() -> PerformanceStreamMarkerInfoINTELBuilder<'a> {
         PerformanceStreamMarkerInfoINTELBuilder {
-            inner: PerformanceStreamMarkerInfoINTEL::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -36946,6 +42768,7 @@ impl<'a> ::std::ops::DerefMut for PerformanceStreamMarkerInfoINTELBuilder<'a> {
     }
 }
 impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> {
+    #[inline]
     pub fn marker(mut self, marker: u32) -> Self {
         self.inner.marker = marker;
         self
@@ -36958,8 +42781,9 @@ impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceOverrideInfoINTEL.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceOverrideInfoINTEL.html>"]
 pub struct PerformanceOverrideInfoINTEL {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -36968,9 +42792,10 @@ pub struct PerformanceOverrideInfoINTEL {
     pub parameter: u64,
 }
 impl ::std::default::Default for PerformanceOverrideInfoINTEL {
-    fn default() -> PerformanceOverrideInfoINTEL {
-        PerformanceOverrideInfoINTEL {
-            s_type: StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             ty: PerformanceOverrideTypeINTEL::default(),
             enable: Bool32::default(),
@@ -36978,10 +42803,13 @@ impl ::std::default::Default for PerformanceOverrideInfoINTEL {
         }
     }
 }
+unsafe impl TaggedStructure for PerformanceOverrideInfoINTEL {
+    const STRUCTURE_TYPE: StructureType = StructureType::PERFORMANCE_OVERRIDE_INFO_INTEL;
+}
 impl PerformanceOverrideInfoINTEL {
     pub fn builder<'a>() -> PerformanceOverrideInfoINTELBuilder<'a> {
         PerformanceOverrideInfoINTELBuilder {
-            inner: PerformanceOverrideInfoINTEL::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37003,14 +42831,17 @@ impl<'a> ::std::ops::DerefMut for PerformanceOverrideInfoINTELBuilder<'a> {
     }
 }
 impl<'a> PerformanceOverrideInfoINTELBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: PerformanceOverrideTypeINTEL) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn enable(mut self, enable: bool) -> Self {
         self.inner.enable = enable.into();
         self
     }
+    #[inline]
     pub fn parameter(mut self, parameter: u64) -> Self {
         self.inner.parameter = parameter;
         self
@@ -37023,26 +42854,32 @@ impl<'a> PerformanceOverrideInfoINTELBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html>"]
 pub struct PerformanceConfigurationAcquireInfoINTEL {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub ty: PerformanceConfigurationTypeINTEL,
 }
 impl ::std::default::Default for PerformanceConfigurationAcquireInfoINTEL {
-    fn default() -> PerformanceConfigurationAcquireInfoINTEL {
-        PerformanceConfigurationAcquireInfoINTEL {
-            s_type: StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             ty: PerformanceConfigurationTypeINTEL::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PerformanceConfigurationAcquireInfoINTEL {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL;
+}
 impl PerformanceConfigurationAcquireInfoINTEL {
     pub fn builder<'a>() -> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
         PerformanceConfigurationAcquireInfoINTELBuilder {
-            inner: PerformanceConfigurationAcquireInfoINTEL::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37064,6 +42901,7 @@ impl<'a> ::std::ops::DerefMut for PerformanceConfigurationAcquireInfoINTELBuilde
     }
 }
 impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: PerformanceConfigurationTypeINTEL) -> Self {
         self.inner.ty = ty;
         self
@@ -37076,8 +42914,9 @@ impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html>"]
 pub struct PhysicalDeviceShaderClockFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -37085,19 +42924,23 @@ pub struct PhysicalDeviceShaderClockFeaturesKHR {
     pub shader_device_clock: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderClockFeaturesKHR {
-    fn default() -> PhysicalDeviceShaderClockFeaturesKHR {
-        PhysicalDeviceShaderClockFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_subgroup_clock: Bool32::default(),
             shader_device_clock: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderClockFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
+}
 impl PhysicalDeviceShaderClockFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
         PhysicalDeviceShaderClockFeaturesKHRBuilder {
-            inner: PhysicalDeviceShaderClockFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37123,10 +42966,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a
     }
 }
 impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self {
         self.inner.shader_subgroup_clock = shader_subgroup_clock.into();
         self
     }
+    #[inline]
     pub fn shader_device_clock(mut self, shader_device_clock: bool) -> Self {
         self.inner.shader_device_clock = shader_device_clock.into();
         self
@@ -37139,26 +42984,32 @@ impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceIndexTypeUint8FeaturesEXT.html>"]
 pub struct PhysicalDeviceIndexTypeUint8FeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub index_type_uint8: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceIndexTypeUint8FeaturesEXT {
-    fn default() -> PhysicalDeviceIndexTypeUint8FeaturesEXT {
-        PhysicalDeviceIndexTypeUint8FeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             index_type_uint8: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceIndexTypeUint8FeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
+}
 impl PhysicalDeviceIndexTypeUint8FeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
         PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder {
-            inner: PhysicalDeviceIndexTypeUint8FeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37184,6 +43035,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder
     }
 }
 impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self {
         self.inner.index_type_uint8 = index_type_uint8.into();
         self
@@ -37196,8 +43048,9 @@ impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html>"]
 pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -37205,19 +43058,24 @@ pub struct PhysicalDeviceShaderSMBuiltinsPropertiesNV {
     pub shader_warps_per_sm: u32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsPropertiesNV {
-    fn default() -> PhysicalDeviceShaderSMBuiltinsPropertiesNV {
-        PhysicalDeviceShaderSMBuiltinsPropertiesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_sm_count: u32::default(),
             shader_warps_per_sm: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderSMBuiltinsPropertiesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV;
+}
 impl PhysicalDeviceShaderSMBuiltinsPropertiesNV {
     pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
         PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder {
-            inner: PhysicalDeviceShaderSMBuiltinsPropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37244,10 +43102,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsPropertiesNVBuil
     }
 }
 impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
+    #[inline]
     pub fn shader_sm_count(mut self, shader_sm_count: u32) -> Self {
         self.inner.shader_sm_count = shader_sm_count;
         self
     }
+    #[inline]
     pub fn shader_warps_per_sm(mut self, shader_warps_per_sm: u32) -> Self {
         self.inner.shader_warps_per_sm = shader_warps_per_sm;
         self
@@ -37260,26 +43120,32 @@ impl<'a> PhysicalDeviceShaderSMBuiltinsPropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html>"]
 pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shader_sm_builtins: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderSMBuiltinsFeaturesNV {
-    fn default() -> PhysicalDeviceShaderSMBuiltinsFeaturesNV {
-        PhysicalDeviceShaderSMBuiltinsFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_sm_builtins: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderSMBuiltinsFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV;
+}
 impl PhysicalDeviceShaderSMBuiltinsFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
         PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder {
-            inner: PhysicalDeviceShaderSMBuiltinsFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37305,6 +43171,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilde
     }
 }
 impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self {
         self.inner.shader_sm_builtins = shader_sm_builtins.into();
         self
@@ -37317,8 +43184,9 @@ impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html>"]
 pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -37327,9 +43195,10 @@ pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
     pub fragment_shader_shading_rate_interlock: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
-    fn default() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
-        PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             fragment_shader_sample_interlock: Bool32::default(),
             fragment_shader_pixel_interlock: Bool32::default(),
@@ -37337,10 +43206,14 @@ impl ::std::default::Default for PhysicalDeviceFragmentShaderInterlockFeaturesEX
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT;
+}
 impl PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
         PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder {
-            inner: PhysicalDeviceFragmentShaderInterlockFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37372,6 +43245,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderInterlockFeaturesE
     }
 }
 impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn fragment_shader_sample_interlock(
         mut self,
         fragment_shader_sample_interlock: bool,
@@ -37379,6 +43253,7 @@ impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
         self.inner.fragment_shader_sample_interlock = fragment_shader_sample_interlock.into();
         self
     }
+    #[inline]
     pub fn fragment_shader_pixel_interlock(
         mut self,
         fragment_shader_pixel_interlock: bool,
@@ -37386,6 +43261,7 @@ impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
         self.inner.fragment_shader_pixel_interlock = fragment_shader_pixel_interlock.into();
         self
     }
+    #[inline]
     pub fn fragment_shader_shading_rate_interlock(
         mut self,
         fragment_shader_shading_rate_interlock: bool,
@@ -37402,26 +43278,32 @@ impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html>"]
 pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub separate_depth_stencil_layouts: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
-    fn default() -> PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
-        PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
-            s_type: StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             separate_depth_stencil_layouts: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
+}
 impl PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
     pub fn builder<'a>() -> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
         PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder {
-            inner: PhysicalDeviceSeparateDepthStencilLayoutsFeatures::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37453,6 +43335,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSeparateDepthStencilLayoutsFeatu
     }
 }
 impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
+    #[inline]
     pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
         self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
         self
@@ -37465,26 +43348,31 @@ impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentReferenceStencilLayout.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentReferenceStencilLayout.html>"]
 pub struct AttachmentReferenceStencilLayout {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub stencil_layout: ImageLayout,
 }
 impl ::std::default::Default for AttachmentReferenceStencilLayout {
-    fn default() -> AttachmentReferenceStencilLayout {
-        AttachmentReferenceStencilLayout {
-            s_type: StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             stencil_layout: ImageLayout::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AttachmentReferenceStencilLayout {
+    const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
+}
 impl AttachmentReferenceStencilLayout {
     pub fn builder<'a>() -> AttachmentReferenceStencilLayoutBuilder<'a> {
         AttachmentReferenceStencilLayoutBuilder {
-            inner: AttachmentReferenceStencilLayout::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37508,6 +43396,7 @@ impl<'a> ::std::ops::DerefMut for AttachmentReferenceStencilLayoutBuilder<'a> {
     }
 }
 impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> {
+    #[inline]
     pub fn stencil_layout(mut self, stencil_layout: ImageLayout) -> Self {
         self.inner.stencil_layout = stencil_layout;
         self
@@ -37520,8 +43409,9 @@ impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html>"]
 pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -37529,19 +43419,24 @@ pub struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
     pub primitive_topology_patch_list_restart: Bool32,
 }
 impl ::std::default::Default for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
-    fn default() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
-        PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             primitive_topology_list_restart: Bool32::default(),
             primitive_topology_patch_list_restart: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT;
+}
 impl PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
         PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder {
-            inner: PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37576,6 +43471,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitiveTopologyListRestartFeat
     }
 }
 impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn primitive_topology_list_restart(
         mut self,
         primitive_topology_list_restart: bool,
@@ -37583,6 +43479,7 @@ impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
         self.inner.primitive_topology_list_restart = primitive_topology_list_restart.into();
         self
     }
+    #[inline]
     pub fn primitive_topology_patch_list_restart(
         mut self,
         primitive_topology_patch_list_restart: bool,
@@ -37599,8 +43496,9 @@ impl<'a> PhysicalDevicePrimitiveTopologyListRestartFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentDescriptionStencilLayout.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentDescriptionStencilLayout.html>"]
 pub struct AttachmentDescriptionStencilLayout {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -37608,19 +43506,23 @@ pub struct AttachmentDescriptionStencilLayout {
     pub stencil_final_layout: ImageLayout,
 }
 impl ::std::default::Default for AttachmentDescriptionStencilLayout {
-    fn default() -> AttachmentDescriptionStencilLayout {
-        AttachmentDescriptionStencilLayout {
-            s_type: StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             stencil_initial_layout: ImageLayout::default(),
             stencil_final_layout: ImageLayout::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AttachmentDescriptionStencilLayout {
+    const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
+}
 impl AttachmentDescriptionStencilLayout {
     pub fn builder<'a>() -> AttachmentDescriptionStencilLayoutBuilder<'a> {
         AttachmentDescriptionStencilLayoutBuilder {
-            inner: AttachmentDescriptionStencilLayout::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37644,10 +43546,12 @@ impl<'a> ::std::ops::DerefMut for AttachmentDescriptionStencilLayoutBuilder<'a>
     }
 }
 impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> {
+    #[inline]
     pub fn stencil_initial_layout(mut self, stencil_initial_layout: ImageLayout) -> Self {
         self.inner.stencil_initial_layout = stencil_initial_layout;
         self
     }
+    #[inline]
     pub fn stencil_final_layout(mut self, stencil_final_layout: ImageLayout) -> Self {
         self.inner.stencil_final_layout = stencil_final_layout;
         self
@@ -37660,26 +43564,32 @@ impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html>"]
 pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub pipeline_executable_info: Bool32,
 }
 impl ::std::default::Default for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
-    fn default() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
-        PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             pipeline_executable_info: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+}
 impl PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
         PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder {
-            inner: PhysicalDevicePipelineExecutablePropertiesFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37714,6 +43624,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineExecutablePropertiesFeat
     }
 }
 impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn pipeline_executable_info(mut self, pipeline_executable_info: bool) -> Self {
         self.inner.pipeline_executable_info = pipeline_executable_info.into();
         self
@@ -37726,26 +43637,31 @@ impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineInfoKHR.html>"]
 pub struct PipelineInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub pipeline: Pipeline,
 }
 impl ::std::default::Default for PipelineInfoKHR {
-    fn default() -> PipelineInfoKHR {
-        PipelineInfoKHR {
-            s_type: StructureType::PIPELINE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             pipeline: Pipeline::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_INFO_KHR;
+}
 impl PipelineInfoKHR {
     pub fn builder<'a>() -> PipelineInfoKHRBuilder<'a> {
         PipelineInfoKHRBuilder {
-            inner: PipelineInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37767,6 +43683,7 @@ impl<'a> ::std::ops::DerefMut for PipelineInfoKHRBuilder<'a> {
     }
 }
 impl<'a> PipelineInfoKHRBuilder<'a> {
+    #[inline]
     pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
         self.inner.pipeline = pipeline;
         self
@@ -37780,7 +43697,7 @@ impl<'a> PipelineInfoKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutablePropertiesKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutablePropertiesKHR.html>"]
 pub struct PipelineExecutablePropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -37789,6 +43706,7 @@ pub struct PipelineExecutablePropertiesKHR {
     pub description: [c_char; MAX_DESCRIPTION_SIZE],
     pub subgroup_size: u32,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for PipelineExecutablePropertiesKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("PipelineExecutablePropertiesKHR")
@@ -37796,19 +43714,20 @@ impl fmt::Debug for PipelineExecutablePropertiesKHR {
             .field("p_next", &self.p_next)
             .field("stages", &self.stages)
             .field("name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
             })
             .field("description", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
             })
             .field("subgroup_size", &self.subgroup_size)
             .finish()
     }
 }
 impl ::std::default::Default for PipelineExecutablePropertiesKHR {
-    fn default() -> PipelineExecutablePropertiesKHR {
-        PipelineExecutablePropertiesKHR {
-            s_type: StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             stages: ShaderStageFlags::default(),
             name: unsafe { ::std::mem::zeroed() },
@@ -37817,10 +43736,13 @@ impl ::std::default::Default for PipelineExecutablePropertiesKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineExecutablePropertiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_PROPERTIES_KHR;
+}
 impl PipelineExecutablePropertiesKHR {
     pub fn builder<'a>() -> PipelineExecutablePropertiesKHRBuilder<'a> {
         PipelineExecutablePropertiesKHRBuilder {
-            inner: PipelineExecutablePropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37842,18 +43764,22 @@ impl<'a> ::std::ops::DerefMut for PipelineExecutablePropertiesKHRBuilder<'a> {
     }
 }
 impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn stages(mut self, stages: ShaderStageFlags) -> Self {
         self.inner.stages = stages;
         self
     }
+    #[inline]
     pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.name = name;
         self
     }
+    #[inline]
     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.description = description;
         self
     }
+    #[inline]
     pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
         self.inner.subgroup_size = subgroup_size;
         self
@@ -37866,8 +43792,9 @@ impl<'a> PipelineExecutablePropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInfoKHR.html>"]
 pub struct PipelineExecutableInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -37875,19 +43802,23 @@ pub struct PipelineExecutableInfoKHR {
     pub executable_index: u32,
 }
 impl ::std::default::Default for PipelineExecutableInfoKHR {
-    fn default() -> PipelineExecutableInfoKHR {
-        PipelineExecutableInfoKHR {
-            s_type: StructureType::PIPELINE_EXECUTABLE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             pipeline: Pipeline::default(),
             executable_index: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineExecutableInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_INFO_KHR;
+}
 impl PipelineExecutableInfoKHR {
     pub fn builder<'a>() -> PipelineExecutableInfoKHRBuilder<'a> {
         PipelineExecutableInfoKHRBuilder {
-            inner: PipelineExecutableInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -37909,10 +43840,12 @@ impl<'a> ::std::ops::DerefMut for PipelineExecutableInfoKHRBuilder<'a> {
     }
 }
 impl<'a> PipelineExecutableInfoKHRBuilder<'a> {
+    #[inline]
     pub fn pipeline(mut self, pipeline: Pipeline) -> Self {
         self.inner.pipeline = pipeline;
         self
     }
+    #[inline]
     pub fn executable_index(mut self, executable_index: u32) -> Self {
         self.inner.executable_index = executable_index;
         self
@@ -37926,7 +43859,7 @@ impl<'a> PipelineExecutableInfoKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableStatisticValueKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticValueKHR.html>"]
 pub union PipelineExecutableStatisticValueKHR {
     pub b32: Bool32,
     pub i64: i64,
@@ -37934,13 +43867,14 @@ pub union PipelineExecutableStatisticValueKHR {
     pub f64: f64,
 }
 impl ::std::default::Default for PipelineExecutableStatisticValueKHR {
-    fn default() -> PipelineExecutableStatisticValueKHR {
+    #[inline]
+    fn default() -> Self {
         unsafe { ::std::mem::zeroed() }
     }
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableStatisticKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticKHR.html>"]
 pub struct PipelineExecutableStatisticKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -37949,16 +43883,17 @@ pub struct PipelineExecutableStatisticKHR {
     pub format: PipelineExecutableStatisticFormatKHR,
     pub value: PipelineExecutableStatisticValueKHR,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for PipelineExecutableStatisticKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("PipelineExecutableStatisticKHR")
             .field("s_type", &self.s_type)
             .field("p_next", &self.p_next)
             .field("name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
             })
             .field("description", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
             })
             .field("format", &self.format)
             .field("value", &"union")
@@ -37966,9 +43901,10 @@ impl fmt::Debug for PipelineExecutableStatisticKHR {
     }
 }
 impl ::std::default::Default for PipelineExecutableStatisticKHR {
-    fn default() -> PipelineExecutableStatisticKHR {
-        PipelineExecutableStatisticKHR {
-            s_type: StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             name: unsafe { ::std::mem::zeroed() },
             description: unsafe { ::std::mem::zeroed() },
@@ -37977,10 +43913,13 @@ impl ::std::default::Default for PipelineExecutableStatisticKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineExecutableStatisticKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_EXECUTABLE_STATISTIC_KHR;
+}
 impl PipelineExecutableStatisticKHR {
     pub fn builder<'a>() -> PipelineExecutableStatisticKHRBuilder<'a> {
         PipelineExecutableStatisticKHRBuilder {
-            inner: PipelineExecutableStatisticKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38002,18 +43941,22 @@ impl<'a> ::std::ops::DerefMut for PipelineExecutableStatisticKHRBuilder<'a> {
     }
 }
 impl<'a> PipelineExecutableStatisticKHRBuilder<'a> {
+    #[inline]
     pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.name = name;
         self
     }
+    #[inline]
     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.description = description;
         self
     }
+    #[inline]
     pub fn format(mut self, format: PipelineExecutableStatisticFormatKHR) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn value(mut self, value: PipelineExecutableStatisticValueKHR) -> Self {
         self.inner.value = value;
         self
@@ -38027,7 +43970,7 @@ impl<'a> PipelineExecutableStatisticKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableInternalRepresentationKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableInternalRepresentationKHR.html>"]
 pub struct PipelineExecutableInternalRepresentationKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -38037,16 +43980,17 @@ pub struct PipelineExecutableInternalRepresentationKHR {
     pub data_size: usize,
     pub p_data: *mut c_void,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for PipelineExecutableInternalRepresentationKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("PipelineExecutableInternalRepresentationKHR")
             .field("s_type", &self.s_type)
             .field("p_next", &self.p_next)
             .field("name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
             })
             .field("description", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
             })
             .field("is_text", &self.is_text)
             .field("data_size", &self.data_size)
@@ -38055,9 +43999,10 @@ impl fmt::Debug for PipelineExecutableInternalRepresentationKHR {
     }
 }
 impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR {
-    fn default() -> PipelineExecutableInternalRepresentationKHR {
-        PipelineExecutableInternalRepresentationKHR {
-            s_type: StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             name: unsafe { ::std::mem::zeroed() },
             description: unsafe { ::std::mem::zeroed() },
@@ -38067,10 +44012,14 @@ impl ::std::default::Default for PipelineExecutableInternalRepresentationKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineExecutableInternalRepresentationKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR;
+}
 impl PipelineExecutableInternalRepresentationKHR {
     pub fn builder<'a>() -> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
         PipelineExecutableInternalRepresentationKHRBuilder {
-            inner: PipelineExecutableInternalRepresentationKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38092,21 +44041,25 @@ impl<'a> ::std::ops::DerefMut for PipelineExecutableInternalRepresentationKHRBui
     }
 }
 impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
+    #[inline]
     pub fn name(mut self, name: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.name = name;
         self
     }
+    #[inline]
     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.description = description;
         self
     }
+    #[inline]
     pub fn is_text(mut self, is_text: bool) -> Self {
         self.inner.is_text = is_text.into();
         self
     }
+    #[inline]
     pub fn data(mut self, data: &'a mut [u8]) -> Self {
-        self.inner.data_size = data.len() as _;
-        self.inner.p_data = data.as_mut_ptr() as *mut c_void;
+        self.inner.data_size = data.len();
+        self.inner.p_data = data.as_mut_ptr().cast();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -38117,62 +44070,67 @@ impl<'a> PipelineExecutableInternalRepresentationKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.html>"]
-pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.html>"]
+pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shader_demote_to_helper_invocation: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
-    fn default() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
-        PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT,
+impl ::std::default::Default for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_demote_to_helper_invocation: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
-        PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder {
-            inner: PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
+}
+impl PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
+    pub fn builder<'a>() -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
+        PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
-    inner: PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT,
+pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
+    inner: PhysicalDeviceShaderDemoteToHelperInvocationFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'_>
+    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_>
 {
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
+    for PhysicalDeviceShaderDemoteToHelperInvocationFeatures
 {
 }
 unsafe impl ExtendsDeviceCreateInfo
-    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'_>
+    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'_>
 {
 }
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
-    type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderDemoteToHelperInvocationFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
+    type Target = PhysicalDeviceShaderDemoteToHelperInvocationFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut
-    for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a>
-{
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesBuilder<'a> {
+    #[inline]
     pub fn shader_demote_to_helper_invocation(
         mut self,
         shader_demote_to_helper_invocation: bool,
@@ -38183,31 +44141,37 @@ impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
+    pub fn build(self) -> PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html>"]
 pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub texel_buffer_alignment: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
-    fn default() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
-        PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             texel_buffer_alignment: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT;
+}
 impl PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
         PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder {
-            inner: PhysicalDeviceTexelBufferAlignmentFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38236,6 +44200,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentFeaturesEXTB
     }
 }
 impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self {
         self.inner.texel_buffer_alignment = texel_buffer_alignment.into();
         self
@@ -38248,9 +44213,10 @@ impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT.html>"]
-pub struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTexelBufferAlignmentProperties.html>"]
+pub struct PhysicalDeviceTexelBufferAlignmentProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
@@ -38258,10 +44224,11 @@ pub struct PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
     pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
     pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
-    fn default() -> PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
-        PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT,
+impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentProperties {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             storage_texel_buffer_offset_alignment_bytes: DeviceSize::default(),
             storage_texel_buffer_offset_single_texel_alignment: Bool32::default(),
@@ -38270,36 +44237,41 @@ impl ::std::default::Default for PhysicalDeviceTexelBufferAlignmentPropertiesEXT
         }
     }
 }
-impl PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
-        PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder {
-            inner: PhysicalDeviceTexelBufferAlignmentPropertiesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceTexelBufferAlignmentProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
+}
+impl PhysicalDeviceTexelBufferAlignmentProperties {
+    pub fn builder<'a>() -> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
+        PhysicalDeviceTexelBufferAlignmentPropertiesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
-    inner: PhysicalDeviceTexelBufferAlignmentPropertiesEXT,
+pub struct PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
+    inner: PhysicalDeviceTexelBufferAlignmentProperties,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceProperties2
-    for PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'_>
+    for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'_>
 {
 }
-unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentPropertiesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
-    type Target = PhysicalDeviceTexelBufferAlignmentPropertiesEXT;
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceTexelBufferAlignmentProperties {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
+    type Target = PhysicalDeviceTexelBufferAlignmentProperties;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesBuilder<'a> {
+    #[inline]
     pub fn storage_texel_buffer_offset_alignment_bytes(
         mut self,
         storage_texel_buffer_offset_alignment_bytes: DeviceSize,
@@ -38308,6 +44280,7 @@ impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
             storage_texel_buffer_offset_alignment_bytes;
         self
     }
+    #[inline]
     pub fn storage_texel_buffer_offset_single_texel_alignment(
         mut self,
         storage_texel_buffer_offset_single_texel_alignment: bool,
@@ -38317,6 +44290,7 @@ impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
             storage_texel_buffer_offset_single_texel_alignment.into();
         self
     }
+    #[inline]
     pub fn uniform_texel_buffer_offset_alignment_bytes(
         mut self,
         uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
@@ -38325,6 +44299,7 @@ impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
             uniform_texel_buffer_offset_alignment_bytes;
         self
     }
+    #[inline]
     pub fn uniform_texel_buffer_offset_single_texel_alignment(
         mut self,
         uniform_texel_buffer_offset_single_texel_alignment: bool,
@@ -38337,65 +44312,73 @@ impl<'a> PhysicalDeviceTexelBufferAlignmentPropertiesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
+    pub fn build(self) -> PhysicalDeviceTexelBufferAlignmentProperties {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeaturesEXT.html>"]
-pub struct PhysicalDeviceSubgroupSizeControlFeaturesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlFeatures.html>"]
+pub struct PhysicalDeviceSubgroupSizeControlFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub subgroup_size_control: Bool32,
     pub compute_full_subgroups: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeaturesEXT {
-    fn default() -> PhysicalDeviceSubgroupSizeControlFeaturesEXT {
-        PhysicalDeviceSubgroupSizeControlFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT,
+impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             subgroup_size_control: Bool32::default(),
             compute_full_subgroups: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceSubgroupSizeControlFeaturesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
-        PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder {
-            inner: PhysicalDeviceSubgroupSizeControlFeaturesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceSubgroupSizeControlFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
+}
+impl PhysicalDeviceSubgroupSizeControlFeatures {
+    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
+        PhysicalDeviceSubgroupSizeControlFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
-    inner: PhysicalDeviceSubgroupSizeControlFeaturesEXT,
+pub struct PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
+    inner: PhysicalDeviceSubgroupSizeControlFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'_>
+    for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_>
 {
 }
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeaturesEXT {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'_> {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
-    type Target = PhysicalDeviceSubgroupSizeControlFeaturesEXT;
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubgroupSizeControlFeatures {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubgroupSizeControlFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
+    type Target = PhysicalDeviceSubgroupSizeControlFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesBuilder<'a> {
+    #[inline]
     pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self {
         self.inner.subgroup_size_control = subgroup_size_control.into();
         self
     }
+    #[inline]
     pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self {
         self.inner.compute_full_subgroups = compute_full_subgroups.into();
         self
@@ -38403,14 +44386,15 @@ impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeaturesEXT {
+    pub fn build(self) -> PhysicalDeviceSubgroupSizeControlFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlPropertiesEXT.html>"]
-pub struct PhysicalDeviceSubgroupSizeControlPropertiesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubgroupSizeControlProperties.html>"]
+pub struct PhysicalDeviceSubgroupSizeControlProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub min_subgroup_size: u32,
@@ -38418,10 +44402,11 @@ pub struct PhysicalDeviceSubgroupSizeControlPropertiesEXT {
     pub max_compute_workgroup_subgroups: u32,
     pub required_subgroup_size_stages: ShaderStageFlags,
 }
-impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlPropertiesEXT {
-    fn default() -> PhysicalDeviceSubgroupSizeControlPropertiesEXT {
-        PhysicalDeviceSubgroupSizeControlPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT,
+impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlProperties {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             min_subgroup_size: u32::default(),
             max_subgroup_size: u32::default(),
@@ -38430,48 +44415,56 @@ impl ::std::default::Default for PhysicalDeviceSubgroupSizeControlPropertiesEXT
         }
     }
 }
-impl PhysicalDeviceSubgroupSizeControlPropertiesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
-        PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder {
-            inner: PhysicalDeviceSubgroupSizeControlPropertiesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceSubgroupSizeControlProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
+}
+impl PhysicalDeviceSubgroupSizeControlProperties {
+    pub fn builder<'a>() -> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
+        PhysicalDeviceSubgroupSizeControlPropertiesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
-    inner: PhysicalDeviceSubgroupSizeControlPropertiesEXT,
+pub struct PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
+    inner: PhysicalDeviceSubgroupSizeControlProperties,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceProperties2
-    for PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'_>
+    for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'_>
 {
 }
-unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlPropertiesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
-    type Target = PhysicalDeviceSubgroupSizeControlPropertiesEXT;
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSubgroupSizeControlProperties {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
+    type Target = PhysicalDeviceSubgroupSizeControlProperties;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesBuilder<'a> {
+    #[inline]
     pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self {
         self.inner.min_subgroup_size = min_subgroup_size;
         self
     }
+    #[inline]
     pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self {
         self.inner.max_subgroup_size = max_subgroup_size;
         self
     }
+    #[inline]
     pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self {
         self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
         self
     }
+    #[inline]
     pub fn required_subgroup_size_stages(
         mut self,
         required_subgroup_size_stages: ShaderStageFlags,
@@ -38482,60 +44475,72 @@ impl<'a> PhysicalDeviceSubgroupSizeControlPropertiesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceSubgroupSizeControlPropertiesEXT {
+    pub fn build(self) -> PhysicalDeviceSubgroupSizeControlProperties {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT.html>"]
-pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.html>"]
+pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfo {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub required_subgroup_size: u32,
 }
-impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
-    fn default() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
-        PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
-            s_type: StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT,
+impl ::std::default::Default for PipelineShaderStageRequiredSubgroupSizeCreateInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             required_subgroup_size: u32::default(),
         }
     }
 }
-impl PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
-    pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
-        PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder {
-            inner: PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::default(),
+unsafe impl TaggedStructure for PipelineShaderStageRequiredSubgroupSizeCreateInfo {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
+}
+impl PipelineShaderStageRequiredSubgroupSizeCreateInfo {
+    pub fn builder<'a>() -> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
+        PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
-    inner: PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT,
+pub struct PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
+    inner: PipelineShaderStageRequiredSubgroupSizeCreateInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPipelineShaderStageCreateInfo
-    for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'_>
+    for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_>
 {
 }
 unsafe impl ExtendsPipelineShaderStageCreateInfo
-    for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
+    for PipelineShaderStageRequiredSubgroupSizeCreateInfo
+{
+}
+unsafe impl ExtendsShaderCreateInfoEXT
+    for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'_>
 {
 }
-impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
-    type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;
+unsafe impl ExtendsShaderCreateInfoEXT for PipelineShaderStageRequiredSubgroupSizeCreateInfo {}
+impl<'a> ::std::ops::Deref for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
+    type Target = PipelineShaderStageRequiredSubgroupSizeCreateInfo;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
+impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoBuilder<'a> {
+    #[inline]
     pub fn required_subgroup_size(mut self, required_subgroup_size: u32) -> Self {
         self.inner.required_subgroup_size = required_subgroup_size;
         self
@@ -38543,13 +44548,14 @@ impl<'a> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
+    pub fn build(self) -> PipelineShaderStageRequiredSubgroupSizeCreateInfo {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassShadingPipelineCreateInfoHUAWEI.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassShadingPipelineCreateInfoHUAWEI.html>"]
 pub struct SubpassShadingPipelineCreateInfoHUAWEI {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -38557,19 +44563,24 @@ pub struct SubpassShadingPipelineCreateInfoHUAWEI {
     pub subpass: u32,
 }
 impl ::std::default::Default for SubpassShadingPipelineCreateInfoHUAWEI {
-    fn default() -> SubpassShadingPipelineCreateInfoHUAWEI {
-        SubpassShadingPipelineCreateInfoHUAWEI {
-            s_type: StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             render_pass: RenderPass::default(),
             subpass: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SubpassShadingPipelineCreateInfoHUAWEI {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI;
+}
 impl SubpassShadingPipelineCreateInfoHUAWEI {
     pub fn builder<'a>() -> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
         SubpassShadingPipelineCreateInfoHUAWEIBuilder {
-            inner: SubpassShadingPipelineCreateInfoHUAWEI::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38593,10 +44604,12 @@ impl<'a> ::std::ops::DerefMut for SubpassShadingPipelineCreateInfoHUAWEIBuilder<
     }
 }
 impl<'a> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
+    #[inline]
     pub fn render_pass(mut self, render_pass: RenderPass) -> Self {
         self.inner.render_pass = render_pass;
         self
     }
+    #[inline]
     pub fn subpass(mut self, subpass: u32) -> Self {
         self.inner.subpass = subpass;
         self
@@ -38609,26 +44622,32 @@ impl<'a> SubpassShadingPipelineCreateInfoHUAWEIBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html>"]
 pub struct PhysicalDeviceSubpassShadingPropertiesHUAWEI {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_subpass_shading_workgroup_size_aspect_ratio: u32,
 }
 impl ::std::default::Default for PhysicalDeviceSubpassShadingPropertiesHUAWEI {
-    fn default() -> PhysicalDeviceSubpassShadingPropertiesHUAWEI {
-        PhysicalDeviceSubpassShadingPropertiesHUAWEI {
-            s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_subpass_shading_workgroup_size_aspect_ratio: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceSubpassShadingPropertiesHUAWEI {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI;
+}
 impl PhysicalDeviceSubpassShadingPropertiesHUAWEI {
     pub fn builder<'a>() -> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
         PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder {
-            inner: PhysicalDeviceSubpassShadingPropertiesHUAWEI::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38655,6 +44674,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingPropertiesHUAWEIBu
     }
 }
 impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
+    #[inline]
     pub fn max_subpass_shading_workgroup_size_aspect_ratio(
         mut self,
         max_subpass_shading_workgroup_size_aspect_ratio: u32,
@@ -38671,26 +44691,124 @@ impl<'a> PhysicalDeviceSubpassShadingPropertiesHUAWEIBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.html>"]
+pub struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub max_work_group_count: [u32; 3],
+    pub max_work_group_size: [u32; 3],
+    pub max_output_cluster_count: u32,
+    pub indirect_buffer_offset_alignment: DeviceSize,
+}
+impl ::std::default::Default for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            max_work_group_count: unsafe { ::std::mem::zeroed() },
+            max_work_group_size: unsafe { ::std::mem::zeroed() },
+            max_output_cluster_count: u32::default(),
+            indirect_buffer_offset_alignment: DeviceSize::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI;
+}
+impl PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
+    pub fn builder<'a>() -> PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
+        PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
+    inner: PhysicalDeviceClusterCullingShaderPropertiesHUAWEI,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceClusterCullingShaderPropertiesHUAWEI
+{
+}
+impl<'a> ::std::ops::Deref for PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
+    type Target = PhysicalDeviceClusterCullingShaderPropertiesHUAWEI;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceClusterCullingShaderPropertiesHUAWEIBuilder<'a> {
+    #[inline]
+    pub fn max_work_group_count(mut self, max_work_group_count: [u32; 3]) -> Self {
+        self.inner.max_work_group_count = max_work_group_count;
+        self
+    }
+    #[inline]
+    pub fn max_work_group_size(mut self, max_work_group_size: [u32; 3]) -> Self {
+        self.inner.max_work_group_size = max_work_group_size;
+        self
+    }
+    #[inline]
+    pub fn max_output_cluster_count(mut self, max_output_cluster_count: u32) -> Self {
+        self.inner.max_output_cluster_count = max_output_cluster_count;
+        self
+    }
+    #[inline]
+    pub fn indirect_buffer_offset_alignment(
+        mut self,
+        indirect_buffer_offset_alignment: DeviceSize,
+    ) -> Self {
+        self.inner.indirect_buffer_offset_alignment = indirect_buffer_offset_alignment;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html>"]
 pub struct MemoryOpaqueCaptureAddressAllocateInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub opaque_capture_address: u64,
 }
 impl ::std::default::Default for MemoryOpaqueCaptureAddressAllocateInfo {
-    fn default() -> MemoryOpaqueCaptureAddressAllocateInfo {
-        MemoryOpaqueCaptureAddressAllocateInfo {
-            s_type: StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             opaque_capture_address: u64::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryOpaqueCaptureAddressAllocateInfo {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
+}
 impl MemoryOpaqueCaptureAddressAllocateInfo {
     pub fn builder<'a>() -> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
         MemoryOpaqueCaptureAddressAllocateInfoBuilder {
-            inner: MemoryOpaqueCaptureAddressAllocateInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38714,6 +44832,7 @@ impl<'a> ::std::ops::DerefMut for MemoryOpaqueCaptureAddressAllocateInfoBuilder<
     }
 }
 impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
+    #[inline]
     pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
         self.inner.opaque_capture_address = opaque_capture_address;
         self
@@ -38726,26 +44845,31 @@ impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html>"]
 pub struct DeviceMemoryOpaqueCaptureAddressInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub memory: DeviceMemory,
 }
 impl ::std::default::Default for DeviceMemoryOpaqueCaptureAddressInfo {
-    fn default() -> DeviceMemoryOpaqueCaptureAddressInfo {
-        DeviceMemoryOpaqueCaptureAddressInfo {
-            s_type: StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             memory: DeviceMemory::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DeviceMemoryOpaqueCaptureAddressInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
+}
 impl DeviceMemoryOpaqueCaptureAddressInfo {
     pub fn builder<'a>() -> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
         DeviceMemoryOpaqueCaptureAddressInfoBuilder {
-            inner: DeviceMemoryOpaqueCaptureAddressInfo::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38767,6 +44891,7 @@ impl<'a> ::std::ops::DerefMut for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a
     }
 }
 impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
@@ -38779,8 +44904,9 @@ impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationFeaturesEXT.html>"]
 pub struct PhysicalDeviceLineRasterizationFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -38792,9 +44918,10 @@ pub struct PhysicalDeviceLineRasterizationFeaturesEXT {
     pub stippled_smooth_lines: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT {
-    fn default() -> PhysicalDeviceLineRasterizationFeaturesEXT {
-        PhysicalDeviceLineRasterizationFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             rectangular_lines: Bool32::default(),
             bresenham_lines: Bool32::default(),
@@ -38805,10 +44932,14 @@ impl ::std::default::Default for PhysicalDeviceLineRasterizationFeaturesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceLineRasterizationFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
+}
 impl PhysicalDeviceLineRasterizationFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
         PhysicalDeviceLineRasterizationFeaturesEXTBuilder {
-            inner: PhysicalDeviceLineRasterizationFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38837,26 +44968,32 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationFeaturesEXTBuil
     }
 }
 impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self {
         self.inner.rectangular_lines = rectangular_lines.into();
         self
     }
+    #[inline]
     pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self {
         self.inner.bresenham_lines = bresenham_lines.into();
         self
     }
+    #[inline]
     pub fn smooth_lines(mut self, smooth_lines: bool) -> Self {
         self.inner.smooth_lines = smooth_lines.into();
         self
     }
+    #[inline]
     pub fn stippled_rectangular_lines(mut self, stippled_rectangular_lines: bool) -> Self {
         self.inner.stippled_rectangular_lines = stippled_rectangular_lines.into();
         self
     }
+    #[inline]
     pub fn stippled_bresenham_lines(mut self, stippled_bresenham_lines: bool) -> Self {
         self.inner.stippled_bresenham_lines = stippled_bresenham_lines.into();
         self
     }
+    #[inline]
     pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self {
         self.inner.stippled_smooth_lines = stippled_smooth_lines.into();
         self
@@ -38869,26 +45006,32 @@ impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLineRasterizationPropertiesEXT.html>"]
 pub struct PhysicalDeviceLineRasterizationPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub line_sub_pixel_precision_bits: u32,
 }
 impl ::std::default::Default for PhysicalDeviceLineRasterizationPropertiesEXT {
-    fn default() -> PhysicalDeviceLineRasterizationPropertiesEXT {
-        PhysicalDeviceLineRasterizationPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             line_sub_pixel_precision_bits: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceLineRasterizationPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
+}
 impl PhysicalDeviceLineRasterizationPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
         PhysicalDeviceLineRasterizationPropertiesEXTBuilder {
-            inner: PhysicalDeviceLineRasterizationPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38915,6 +45058,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceLineRasterizationPropertiesEXTBu
     }
 }
 impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn line_sub_pixel_precision_bits(mut self, line_sub_pixel_precision_bits: u32) -> Self {
         self.inner.line_sub_pixel_precision_bits = line_sub_pixel_precision_bits;
         self
@@ -38927,8 +45071,9 @@ impl<'a> PhysicalDeviceLineRasterizationPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationLineStateCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationLineStateCreateInfoEXT.html>"]
 pub struct PipelineRasterizationLineStateCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -38938,9 +45083,10 @@ pub struct PipelineRasterizationLineStateCreateInfoEXT {
     pub line_stipple_pattern: u16,
 }
 impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT {
-    fn default() -> PipelineRasterizationLineStateCreateInfoEXT {
-        PipelineRasterizationLineStateCreateInfoEXT {
-            s_type: StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             line_rasterization_mode: LineRasterizationModeEXT::default(),
             stippled_line_enable: Bool32::default(),
@@ -38949,10 +45095,14 @@ impl ::std::default::Default for PipelineRasterizationLineStateCreateInfoEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PipelineRasterizationLineStateCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
+}
 impl PipelineRasterizationLineStateCreateInfoEXT {
     pub fn builder<'a>() -> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
         PipelineRasterizationLineStateCreateInfoEXTBuilder {
-            inner: PipelineRasterizationLineStateCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -38982,6 +45132,7 @@ impl<'a> ::std::ops::DerefMut for PipelineRasterizationLineStateCreateInfoEXTBui
     }
 }
 impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn line_rasterization_mode(
         mut self,
         line_rasterization_mode: LineRasterizationModeEXT,
@@ -38989,14 +45140,17 @@ impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
         self.inner.line_rasterization_mode = line_rasterization_mode;
         self
     }
+    #[inline]
     pub fn stippled_line_enable(mut self, stippled_line_enable: bool) -> Self {
         self.inner.stippled_line_enable = stippled_line_enable.into();
         self
     }
+    #[inline]
     pub fn line_stipple_factor(mut self, line_stipple_factor: u32) -> Self {
         self.inner.line_stipple_factor = line_stipple_factor;
         self
     }
+    #[inline]
     pub fn line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self {
         self.inner.line_stipple_pattern = line_stipple_pattern;
         self
@@ -39009,60 +45163,64 @@ impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT.html>"]
-pub struct PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineCreationCacheControlFeatures.html>"]
+pub struct PhysicalDevicePipelineCreationCacheControlFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub pipeline_creation_cache_control: Bool32,
 }
-impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
-    fn default() -> PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
-        PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT,
+impl ::std::default::Default for PhysicalDevicePipelineCreationCacheControlFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             pipeline_creation_cache_control: Bool32::default(),
         }
     }
 }
-impl PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
-    pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
-        PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder {
-            inner: PhysicalDevicePipelineCreationCacheControlFeaturesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDevicePipelineCreationCacheControlFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
+}
+impl PhysicalDevicePipelineCreationCacheControlFeatures {
+    pub fn builder<'a>() -> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
+        PhysicalDevicePipelineCreationCacheControlFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
-    inner: PhysicalDevicePipelineCreationCacheControlFeaturesEXT,
+pub struct PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
+    inner: PhysicalDevicePipelineCreationCacheControlFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'_>
-{
-}
-unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDevicePipelineCreationCacheControlFeaturesEXT
+    for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_>
 {
 }
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineCreationCacheControlFeatures {}
 unsafe impl ExtendsDeviceCreateInfo
-    for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'_>
+    for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'_>
 {
 }
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeaturesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
-    type Target = PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineCreationCacheControlFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
+    type Target = PhysicalDevicePipelineCreationCacheControlFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
+impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesBuilder<'a> {
+    #[inline]
     pub fn pipeline_creation_cache_control(
         mut self,
         pipeline_creation_cache_control: bool,
@@ -39073,13 +45231,14 @@ impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
+    pub fn build(self) -> PhysicalDevicePipelineCreationCacheControlFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Features.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Features.html>"]
 pub struct PhysicalDeviceVulkan11Features {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -39097,9 +45256,10 @@ pub struct PhysicalDeviceVulkan11Features {
     pub shader_draw_parameters: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceVulkan11Features {
-    fn default() -> PhysicalDeviceVulkan11Features {
-        PhysicalDeviceVulkan11Features {
-            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             storage_buffer16_bit_access: Bool32::default(),
             uniform_and_storage_buffer16_bit_access: Bool32::default(),
@@ -39116,10 +45276,13 @@ impl ::std::default::Default for PhysicalDeviceVulkan11Features {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVulkan11Features {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
+}
 impl PhysicalDeviceVulkan11Features {
     pub fn builder<'a>() -> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
         PhysicalDeviceVulkan11FeaturesBuilder {
-            inner: PhysicalDeviceVulkan11Features::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -39145,10 +45308,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
+    #[inline]
     pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
         self.inner.storage_buffer16_bit_access = storage_buffer16_bit_access.into();
         self
     }
+    #[inline]
     pub fn uniform_and_storage_buffer16_bit_access(
         mut self,
         uniform_and_storage_buffer16_bit_access: bool,
@@ -39157,26 +45322,32 @@ impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
             uniform_and_storage_buffer16_bit_access.into();
         self
     }
+    #[inline]
     pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
         self.inner.storage_push_constant16 = storage_push_constant16.into();
         self
     }
+    #[inline]
     pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
         self.inner.storage_input_output16 = storage_input_output16.into();
         self
     }
+    #[inline]
     pub fn multiview(mut self, multiview: bool) -> Self {
         self.inner.multiview = multiview.into();
         self
     }
+    #[inline]
     pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
         self.inner.multiview_geometry_shader = multiview_geometry_shader.into();
         self
     }
+    #[inline]
     pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
         self.inner.multiview_tessellation_shader = multiview_tessellation_shader.into();
         self
     }
+    #[inline]
     pub fn variable_pointers_storage_buffer(
         mut self,
         variable_pointers_storage_buffer: bool,
@@ -39184,18 +45355,22 @@ impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
         self.inner.variable_pointers_storage_buffer = variable_pointers_storage_buffer.into();
         self
     }
+    #[inline]
     pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
         self.inner.variable_pointers = variable_pointers.into();
         self
     }
+    #[inline]
     pub fn protected_memory(mut self, protected_memory: bool) -> Self {
         self.inner.protected_memory = protected_memory.into();
         self
     }
+    #[inline]
     pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
         self.inner.sampler_ycbcr_conversion = sampler_ycbcr_conversion.into();
         self
     }
+    #[inline]
     pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
         self.inner.shader_draw_parameters = shader_draw_parameters.into();
         self
@@ -39208,8 +45383,9 @@ impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan11Properties.html>"]
 pub struct PhysicalDeviceVulkan11Properties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -39230,9 +45406,10 @@ pub struct PhysicalDeviceVulkan11Properties {
     pub max_memory_allocation_size: DeviceSize,
 }
 impl ::std::default::Default for PhysicalDeviceVulkan11Properties {
-    fn default() -> PhysicalDeviceVulkan11Properties {
-        PhysicalDeviceVulkan11Properties {
-            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             device_uuid: unsafe { ::std::mem::zeroed() },
             driver_uuid: unsafe { ::std::mem::zeroed() },
@@ -39252,10 +45429,13 @@ impl ::std::default::Default for PhysicalDeviceVulkan11Properties {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVulkan11Properties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES;
+}
 impl PhysicalDeviceVulkan11Properties {
     pub fn builder<'a>() -> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
         PhysicalDeviceVulkan11PropertiesBuilder {
-            inner: PhysicalDeviceVulkan11Properties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -39279,30 +45459,37 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
+    #[inline]
     pub fn device_uuid(mut self, device_uuid: [u8; UUID_SIZE]) -> Self {
         self.inner.device_uuid = device_uuid;
         self
     }
+    #[inline]
     pub fn driver_uuid(mut self, driver_uuid: [u8; UUID_SIZE]) -> Self {
         self.inner.driver_uuid = driver_uuid;
         self
     }
+    #[inline]
     pub fn device_luid(mut self, device_luid: [u8; LUID_SIZE]) -> Self {
         self.inner.device_luid = device_luid;
         self
     }
+    #[inline]
     pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
         self.inner.device_node_mask = device_node_mask;
         self
     }
+    #[inline]
     pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
         self.inner.device_luid_valid = device_luid_valid.into();
         self
     }
+    #[inline]
     pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
         self.inner.subgroup_size = subgroup_size;
         self
     }
+    #[inline]
     pub fn subgroup_supported_stages(
         mut self,
         subgroup_supported_stages: ShaderStageFlags,
@@ -39310,6 +45497,7 @@ impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
         self.inner.subgroup_supported_stages = subgroup_supported_stages;
         self
     }
+    #[inline]
     pub fn subgroup_supported_operations(
         mut self,
         subgroup_supported_operations: SubgroupFeatureFlags,
@@ -39317,6 +45505,7 @@ impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
         self.inner.subgroup_supported_operations = subgroup_supported_operations;
         self
     }
+    #[inline]
     pub fn subgroup_quad_operations_in_all_stages(
         mut self,
         subgroup_quad_operations_in_all_stages: bool,
@@ -39325,6 +45514,7 @@ impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
             subgroup_quad_operations_in_all_stages.into();
         self
     }
+    #[inline]
     pub fn point_clipping_behavior(
         mut self,
         point_clipping_behavior: PointClippingBehavior,
@@ -39332,22 +45522,27 @@ impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
         self.inner.point_clipping_behavior = point_clipping_behavior;
         self
     }
+    #[inline]
     pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
         self.inner.max_multiview_view_count = max_multiview_view_count;
         self
     }
+    #[inline]
     pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
         self.inner.max_multiview_instance_index = max_multiview_instance_index;
         self
     }
+    #[inline]
     pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
         self.inner.protected_no_fault = protected_no_fault.into();
         self
     }
+    #[inline]
     pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
         self.inner.max_per_set_descriptors = max_per_set_descriptors;
         self
     }
+    #[inline]
     pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: DeviceSize) -> Self {
         self.inner.max_memory_allocation_size = max_memory_allocation_size;
         self
@@ -39360,8 +45555,9 @@ impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Features.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Features.html>"]
 pub struct PhysicalDeviceVulkan12Features {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -39414,9 +45610,10 @@ pub struct PhysicalDeviceVulkan12Features {
     pub subgroup_broadcast_dynamic_id: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceVulkan12Features {
-    fn default() -> PhysicalDeviceVulkan12Features {
-        PhysicalDeviceVulkan12Features {
-            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             sampler_mirror_clamp_to_edge: Bool32::default(),
             draw_indirect_count: Bool32::default(),
@@ -39468,10 +45665,13 @@ impl ::std::default::Default for PhysicalDeviceVulkan12Features {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVulkan12Features {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
+}
 impl PhysicalDeviceVulkan12Features {
     pub fn builder<'a>() -> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
         PhysicalDeviceVulkan12FeaturesBuilder {
-            inner: PhysicalDeviceVulkan12Features::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -39497,18 +45697,22 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
+    #[inline]
     pub fn sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self {
         self.inner.sampler_mirror_clamp_to_edge = sampler_mirror_clamp_to_edge.into();
         self
     }
+    #[inline]
     pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self {
         self.inner.draw_indirect_count = draw_indirect_count.into();
         self
     }
+    #[inline]
     pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
         self.inner.storage_buffer8_bit_access = storage_buffer8_bit_access.into();
         self
     }
+    #[inline]
     pub fn uniform_and_storage_buffer8_bit_access(
         mut self,
         uniform_and_storage_buffer8_bit_access: bool,
@@ -39517,30 +45721,37 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             uniform_and_storage_buffer8_bit_access.into();
         self
     }
+    #[inline]
     pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
         self.inner.storage_push_constant8 = storage_push_constant8.into();
         self
     }
+    #[inline]
     pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
         self.inner.shader_buffer_int64_atomics = shader_buffer_int64_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
         self.inner.shader_shared_int64_atomics = shader_shared_int64_atomics.into();
         self
     }
+    #[inline]
     pub fn shader_float16(mut self, shader_float16: bool) -> Self {
         self.inner.shader_float16 = shader_float16.into();
         self
     }
+    #[inline]
     pub fn shader_int8(mut self, shader_int8: bool) -> Self {
         self.inner.shader_int8 = shader_int8.into();
         self
     }
+    #[inline]
     pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self {
         self.inner.descriptor_indexing = descriptor_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_input_attachment_array_dynamic_indexing(
         mut self,
         shader_input_attachment_array_dynamic_indexing: bool,
@@ -39549,6 +45760,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_input_attachment_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
         mut self,
         shader_uniform_texel_buffer_array_dynamic_indexing: bool,
@@ -39558,6 +45770,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_uniform_texel_buffer_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_texel_buffer_array_dynamic_indexing(
         mut self,
         shader_storage_texel_buffer_array_dynamic_indexing: bool,
@@ -39567,6 +45780,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_storage_texel_buffer_array_dynamic_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_uniform_buffer_array_non_uniform_indexing(
         mut self,
         shader_uniform_buffer_array_non_uniform_indexing: bool,
@@ -39575,6 +45789,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_uniform_buffer_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_sampled_image_array_non_uniform_indexing(
         mut self,
         shader_sampled_image_array_non_uniform_indexing: bool,
@@ -39583,6 +45798,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_sampled_image_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_buffer_array_non_uniform_indexing(
         mut self,
         shader_storage_buffer_array_non_uniform_indexing: bool,
@@ -39591,6 +45807,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_storage_buffer_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_image_array_non_uniform_indexing(
         mut self,
         shader_storage_image_array_non_uniform_indexing: bool,
@@ -39599,6 +45816,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_storage_image_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_input_attachment_array_non_uniform_indexing(
         mut self,
         shader_input_attachment_array_non_uniform_indexing: bool,
@@ -39608,6 +45826,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_input_attachment_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
         mut self,
         shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
@@ -39617,6 +45836,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_uniform_texel_buffer_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
         mut self,
         shader_storage_texel_buffer_array_non_uniform_indexing: bool,
@@ -39626,6 +45846,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             shader_storage_texel_buffer_array_non_uniform_indexing.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_uniform_buffer_update_after_bind(
         mut self,
         descriptor_binding_uniform_buffer_update_after_bind: bool,
@@ -39635,6 +45856,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             descriptor_binding_uniform_buffer_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_sampled_image_update_after_bind(
         mut self,
         descriptor_binding_sampled_image_update_after_bind: bool,
@@ -39644,6 +45866,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             descriptor_binding_sampled_image_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_storage_image_update_after_bind(
         mut self,
         descriptor_binding_storage_image_update_after_bind: bool,
@@ -39653,6 +45876,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             descriptor_binding_storage_image_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_storage_buffer_update_after_bind(
         mut self,
         descriptor_binding_storage_buffer_update_after_bind: bool,
@@ -39662,6 +45886,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             descriptor_binding_storage_buffer_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
         mut self,
         descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
@@ -39671,6 +45896,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             descriptor_binding_uniform_texel_buffer_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
         mut self,
         descriptor_binding_storage_texel_buffer_update_after_bind: bool,
@@ -39680,6 +45906,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             descriptor_binding_storage_texel_buffer_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_update_unused_while_pending(
         mut self,
         descriptor_binding_update_unused_while_pending: bool,
@@ -39688,6 +45915,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             descriptor_binding_update_unused_while_pending.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_partially_bound(
         mut self,
         descriptor_binding_partially_bound: bool,
@@ -39695,6 +45923,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
         self.inner.descriptor_binding_partially_bound = descriptor_binding_partially_bound.into();
         self
     }
+    #[inline]
     pub fn descriptor_binding_variable_descriptor_count(
         mut self,
         descriptor_binding_variable_descriptor_count: bool,
@@ -39703,46 +45932,57 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             descriptor_binding_variable_descriptor_count.into();
         self
     }
+    #[inline]
     pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
         self.inner.runtime_descriptor_array = runtime_descriptor_array.into();
         self
     }
+    #[inline]
     pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self {
         self.inner.sampler_filter_minmax = sampler_filter_minmax.into();
         self
     }
+    #[inline]
     pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
         self.inner.scalar_block_layout = scalar_block_layout.into();
         self
     }
+    #[inline]
     pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
         self.inner.imageless_framebuffer = imageless_framebuffer.into();
         self
     }
+    #[inline]
     pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
         self.inner.uniform_buffer_standard_layout = uniform_buffer_standard_layout.into();
         self
     }
+    #[inline]
     pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
         self.inner.shader_subgroup_extended_types = shader_subgroup_extended_types.into();
         self
     }
+    #[inline]
     pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
         self.inner.separate_depth_stencil_layouts = separate_depth_stencil_layouts.into();
         self
     }
+    #[inline]
     pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
         self.inner.host_query_reset = host_query_reset.into();
         self
     }
+    #[inline]
     pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
         self.inner.timeline_semaphore = timeline_semaphore.into();
         self
     }
+    #[inline]
     pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
         self.inner.buffer_device_address = buffer_device_address.into();
         self
     }
+    #[inline]
     pub fn buffer_device_address_capture_replay(
         mut self,
         buffer_device_address_capture_replay: bool,
@@ -39751,6 +45991,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             buffer_device_address_capture_replay.into();
         self
     }
+    #[inline]
     pub fn buffer_device_address_multi_device(
         mut self,
         buffer_device_address_multi_device: bool,
@@ -39758,10 +45999,12 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
         self.inner.buffer_device_address_multi_device = buffer_device_address_multi_device.into();
         self
     }
+    #[inline]
     pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
         self.inner.vulkan_memory_model = vulkan_memory_model.into();
         self
     }
+    #[inline]
     pub fn vulkan_memory_model_device_scope(
         mut self,
         vulkan_memory_model_device_scope: bool,
@@ -39769,6 +46012,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
         self.inner.vulkan_memory_model_device_scope = vulkan_memory_model_device_scope.into();
         self
     }
+    #[inline]
     pub fn vulkan_memory_model_availability_visibility_chains(
         mut self,
         vulkan_memory_model_availability_visibility_chains: bool,
@@ -39778,14 +46022,17 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
             vulkan_memory_model_availability_visibility_chains.into();
         self
     }
+    #[inline]
     pub fn shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self {
         self.inner.shader_output_viewport_index = shader_output_viewport_index.into();
         self
     }
+    #[inline]
     pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self {
         self.inner.shader_output_layer = shader_output_layer.into();
         self
     }
+    #[inline]
     pub fn subgroup_broadcast_dynamic_id(mut self, subgroup_broadcast_dynamic_id: bool) -> Self {
         self.inner.subgroup_broadcast_dynamic_id = subgroup_broadcast_dynamic_id.into();
         self
@@ -39799,7 +46046,7 @@ impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan12Properties.html>"]
 pub struct PhysicalDeviceVulkan12Properties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -39856,6 +46103,7 @@ pub struct PhysicalDeviceVulkan12Properties {
     pub max_timeline_semaphore_value_difference: u64,
     pub framebuffer_integer_color_sample_counts: SampleCountFlags,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for PhysicalDeviceVulkan12Properties {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("PhysicalDeviceVulkan12Properties")
@@ -39863,10 +46111,10 @@ impl fmt::Debug for PhysicalDeviceVulkan12Properties {
             .field("p_next", &self.p_next)
             .field("driver_id", &self.driver_id)
             .field("driver_name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.driver_name.as_ptr())
             })
             .field("driver_info", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.driver_info.as_ptr())
             })
             .field("conformance_version", &self.conformance_version)
             .field(
@@ -40059,9 +46307,10 @@ impl fmt::Debug for PhysicalDeviceVulkan12Properties {
     }
 }
 impl ::std::default::Default for PhysicalDeviceVulkan12Properties {
-    fn default() -> PhysicalDeviceVulkan12Properties {
-        PhysicalDeviceVulkan12Properties {
-            s_type: StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             driver_id: DriverId::default(),
             driver_name: unsafe { ::std::mem::zeroed() },
@@ -40118,10 +46367,13 @@ impl ::std::default::Default for PhysicalDeviceVulkan12Properties {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVulkan12Properties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES;
+}
 impl PhysicalDeviceVulkan12Properties {
     pub fn builder<'a>() -> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         PhysicalDeviceVulkan12PropertiesBuilder {
-            inner: PhysicalDeviceVulkan12Properties::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -40145,22 +46397,27 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
+    #[inline]
     pub fn driver_id(mut self, driver_id: DriverId) -> Self {
         self.inner.driver_id = driver_id;
         self
     }
+    #[inline]
     pub fn driver_name(mut self, driver_name: [c_char; MAX_DRIVER_NAME_SIZE]) -> Self {
         self.inner.driver_name = driver_name;
         self
     }
+    #[inline]
     pub fn driver_info(mut self, driver_info: [c_char; MAX_DRIVER_INFO_SIZE]) -> Self {
         self.inner.driver_info = driver_info;
         self
     }
+    #[inline]
     pub fn conformance_version(mut self, conformance_version: ConformanceVersion) -> Self {
         self.inner.conformance_version = conformance_version;
         self
     }
+    #[inline]
     pub fn denorm_behavior_independence(
         mut self,
         denorm_behavior_independence: ShaderFloatControlsIndependence,
@@ -40168,6 +46425,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.denorm_behavior_independence = denorm_behavior_independence;
         self
     }
+    #[inline]
     pub fn rounding_mode_independence(
         mut self,
         rounding_mode_independence: ShaderFloatControlsIndependence,
@@ -40175,6 +46433,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.rounding_mode_independence = rounding_mode_independence;
         self
     }
+    #[inline]
     pub fn shader_signed_zero_inf_nan_preserve_float16(
         mut self,
         shader_signed_zero_inf_nan_preserve_float16: bool,
@@ -40183,6 +46442,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             shader_signed_zero_inf_nan_preserve_float16.into();
         self
     }
+    #[inline]
     pub fn shader_signed_zero_inf_nan_preserve_float32(
         mut self,
         shader_signed_zero_inf_nan_preserve_float32: bool,
@@ -40191,6 +46451,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             shader_signed_zero_inf_nan_preserve_float32.into();
         self
     }
+    #[inline]
     pub fn shader_signed_zero_inf_nan_preserve_float64(
         mut self,
         shader_signed_zero_inf_nan_preserve_float64: bool,
@@ -40199,18 +46460,22 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             shader_signed_zero_inf_nan_preserve_float64.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self {
         self.inner.shader_denorm_preserve_float16 = shader_denorm_preserve_float16.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self {
         self.inner.shader_denorm_preserve_float32 = shader_denorm_preserve_float32.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self {
         self.inner.shader_denorm_preserve_float64 = shader_denorm_preserve_float64.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_flush_to_zero_float16(
         mut self,
         shader_denorm_flush_to_zero_float16: bool,
@@ -40218,6 +46483,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.shader_denorm_flush_to_zero_float16 = shader_denorm_flush_to_zero_float16.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_flush_to_zero_float32(
         mut self,
         shader_denorm_flush_to_zero_float32: bool,
@@ -40225,6 +46491,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.shader_denorm_flush_to_zero_float32 = shader_denorm_flush_to_zero_float32.into();
         self
     }
+    #[inline]
     pub fn shader_denorm_flush_to_zero_float64(
         mut self,
         shader_denorm_flush_to_zero_float64: bool,
@@ -40232,6 +46499,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.shader_denorm_flush_to_zero_float64 = shader_denorm_flush_to_zero_float64.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rte_float16(
         mut self,
         shader_rounding_mode_rte_float16: bool,
@@ -40239,6 +46507,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rte_float16 = shader_rounding_mode_rte_float16.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rte_float32(
         mut self,
         shader_rounding_mode_rte_float32: bool,
@@ -40246,6 +46515,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rte_float32 = shader_rounding_mode_rte_float32.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rte_float64(
         mut self,
         shader_rounding_mode_rte_float64: bool,
@@ -40253,6 +46523,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rte_float64 = shader_rounding_mode_rte_float64.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rtz_float16(
         mut self,
         shader_rounding_mode_rtz_float16: bool,
@@ -40260,6 +46531,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rtz_float16 = shader_rounding_mode_rtz_float16.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rtz_float32(
         mut self,
         shader_rounding_mode_rtz_float32: bool,
@@ -40267,6 +46539,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rtz_float32 = shader_rounding_mode_rtz_float32.into();
         self
     }
+    #[inline]
     pub fn shader_rounding_mode_rtz_float64(
         mut self,
         shader_rounding_mode_rtz_float64: bool,
@@ -40274,6 +46547,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.shader_rounding_mode_rtz_float64 = shader_rounding_mode_rtz_float64.into();
         self
     }
+    #[inline]
     pub fn max_update_after_bind_descriptors_in_all_pools(
         mut self,
         max_update_after_bind_descriptors_in_all_pools: u32,
@@ -40282,6 +46556,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_update_after_bind_descriptors_in_all_pools;
         self
     }
+    #[inline]
     pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
         mut self,
         shader_uniform_buffer_array_non_uniform_indexing_native: bool,
@@ -40291,6 +46566,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             shader_uniform_buffer_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn shader_sampled_image_array_non_uniform_indexing_native(
         mut self,
         shader_sampled_image_array_non_uniform_indexing_native: bool,
@@ -40300,6 +46576,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             shader_sampled_image_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn shader_storage_buffer_array_non_uniform_indexing_native(
         mut self,
         shader_storage_buffer_array_non_uniform_indexing_native: bool,
@@ -40309,6 +46586,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             shader_storage_buffer_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn shader_storage_image_array_non_uniform_indexing_native(
         mut self,
         shader_storage_image_array_non_uniform_indexing_native: bool,
@@ -40318,6 +46596,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             shader_storage_image_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn shader_input_attachment_array_non_uniform_indexing_native(
         mut self,
         shader_input_attachment_array_non_uniform_indexing_native: bool,
@@ -40327,6 +46606,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             shader_input_attachment_array_non_uniform_indexing_native.into();
         self
     }
+    #[inline]
     pub fn robust_buffer_access_update_after_bind(
         mut self,
         robust_buffer_access_update_after_bind: bool,
@@ -40335,10 +46615,12 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             robust_buffer_access_update_after_bind.into();
         self
     }
+    #[inline]
     pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
         self.inner.quad_divergent_implicit_lod = quad_divergent_implicit_lod.into();
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_samplers(
         mut self,
         max_per_stage_descriptor_update_after_bind_samplers: u32,
@@ -40348,6 +46630,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_samplers;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
         mut self,
         max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
@@ -40357,6 +46640,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_uniform_buffers;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
         mut self,
         max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
@@ -40366,6 +46650,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_storage_buffers;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
         mut self,
         max_per_stage_descriptor_update_after_bind_sampled_images: u32,
@@ -40375,6 +46660,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_sampled_images;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_storage_images(
         mut self,
         max_per_stage_descriptor_update_after_bind_storage_images: u32,
@@ -40384,6 +46670,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_storage_images;
         self
     }
+    #[inline]
     pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
         mut self,
         max_per_stage_descriptor_update_after_bind_input_attachments: u32,
@@ -40393,6 +46680,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_per_stage_descriptor_update_after_bind_input_attachments;
         self
     }
+    #[inline]
     pub fn max_per_stage_update_after_bind_resources(
         mut self,
         max_per_stage_update_after_bind_resources: u32,
@@ -40401,6 +46689,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_per_stage_update_after_bind_resources;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_samplers(
         mut self,
         max_descriptor_set_update_after_bind_samplers: u32,
@@ -40409,6 +46698,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_samplers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_uniform_buffers(
         mut self,
         max_descriptor_set_update_after_bind_uniform_buffers: u32,
@@ -40418,6 +46708,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_uniform_buffers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
         mut self,
         max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
@@ -40427,6 +46718,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_storage_buffers(
         mut self,
         max_descriptor_set_update_after_bind_storage_buffers: u32,
@@ -40436,6 +46728,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_storage_buffers;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
         mut self,
         max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
@@ -40445,6 +46738,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_storage_buffers_dynamic;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_sampled_images(
         mut self,
         max_descriptor_set_update_after_bind_sampled_images: u32,
@@ -40454,6 +46748,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_sampled_images;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_storage_images(
         mut self,
         max_descriptor_set_update_after_bind_storage_images: u32,
@@ -40463,6 +46758,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_storage_images;
         self
     }
+    #[inline]
     pub fn max_descriptor_set_update_after_bind_input_attachments(
         mut self,
         max_descriptor_set_update_after_bind_input_attachments: u32,
@@ -40472,6 +46768,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_descriptor_set_update_after_bind_input_attachments;
         self
     }
+    #[inline]
     pub fn supported_depth_resolve_modes(
         mut self,
         supported_depth_resolve_modes: ResolveModeFlags,
@@ -40479,6 +46776,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
         self
     }
+    #[inline]
     pub fn supported_stencil_resolve_modes(
         mut self,
         supported_stencil_resolve_modes: ResolveModeFlags,
@@ -40486,14 +46784,17 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
         self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
         self
     }
+    #[inline]
     pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
         self.inner.independent_resolve_none = independent_resolve_none.into();
         self
     }
+    #[inline]
     pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
         self.inner.independent_resolve = independent_resolve.into();
         self
     }
+    #[inline]
     pub fn filter_minmax_single_component_formats(
         mut self,
         filter_minmax_single_component_formats: bool,
@@ -40502,6 +46803,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             filter_minmax_single_component_formats.into();
         self
     }
+    #[inline]
     pub fn filter_minmax_image_component_mapping(
         mut self,
         filter_minmax_image_component_mapping: bool,
@@ -40510,6 +46812,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             filter_minmax_image_component_mapping.into();
         self
     }
+    #[inline]
     pub fn max_timeline_semaphore_value_difference(
         mut self,
         max_timeline_semaphore_value_difference: u64,
@@ -40518,6 +46821,7 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
             max_timeline_semaphore_value_difference;
         self
     }
+    #[inline]
     pub fn framebuffer_integer_color_sample_counts(
         mut self,
         framebuffer_integer_color_sample_counts: SampleCountFlags,
@@ -40534,26 +46838,708 @@ impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCompilerControlCreateInfoAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan13Features.html>"]
+pub struct PhysicalDeviceVulkan13Features {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub robust_image_access: Bool32,
+    pub inline_uniform_block: Bool32,
+    pub descriptor_binding_inline_uniform_block_update_after_bind: Bool32,
+    pub pipeline_creation_cache_control: Bool32,
+    pub private_data: Bool32,
+    pub shader_demote_to_helper_invocation: Bool32,
+    pub shader_terminate_invocation: Bool32,
+    pub subgroup_size_control: Bool32,
+    pub compute_full_subgroups: Bool32,
+    pub synchronization2: Bool32,
+    pub texture_compression_astc_hdr: Bool32,
+    pub shader_zero_initialize_workgroup_memory: Bool32,
+    pub dynamic_rendering: Bool32,
+    pub shader_integer_dot_product: Bool32,
+    pub maintenance4: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceVulkan13Features {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            robust_image_access: Bool32::default(),
+            inline_uniform_block: Bool32::default(),
+            descriptor_binding_inline_uniform_block_update_after_bind: Bool32::default(),
+            pipeline_creation_cache_control: Bool32::default(),
+            private_data: Bool32::default(),
+            shader_demote_to_helper_invocation: Bool32::default(),
+            shader_terminate_invocation: Bool32::default(),
+            subgroup_size_control: Bool32::default(),
+            compute_full_subgroups: Bool32::default(),
+            synchronization2: Bool32::default(),
+            texture_compression_astc_hdr: Bool32::default(),
+            shader_zero_initialize_workgroup_memory: Bool32::default(),
+            dynamic_rendering: Bool32::default(),
+            shader_integer_dot_product: Bool32::default(),
+            maintenance4: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceVulkan13Features {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+}
+impl PhysicalDeviceVulkan13Features {
+    pub fn builder<'a>() -> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
+        PhysicalDeviceVulkan13FeaturesBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceVulkan13FeaturesBuilder<'a> {
+    inner: PhysicalDeviceVulkan13Features,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13FeaturesBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceVulkan13Features {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13FeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceVulkan13Features {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
+    type Target = PhysicalDeviceVulkan13Features;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13FeaturesBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceVulkan13FeaturesBuilder<'a> {
+    #[inline]
+    pub fn robust_image_access(mut self, robust_image_access: bool) -> Self {
+        self.inner.robust_image_access = robust_image_access.into();
+        self
+    }
+    #[inline]
+    pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self {
+        self.inner.inline_uniform_block = inline_uniform_block.into();
+        self
+    }
+    #[inline]
+    pub fn descriptor_binding_inline_uniform_block_update_after_bind(
+        mut self,
+        descriptor_binding_inline_uniform_block_update_after_bind: bool,
+    ) -> Self {
+        self.inner
+            .descriptor_binding_inline_uniform_block_update_after_bind =
+            descriptor_binding_inline_uniform_block_update_after_bind.into();
+        self
+    }
+    #[inline]
+    pub fn pipeline_creation_cache_control(
+        mut self,
+        pipeline_creation_cache_control: bool,
+    ) -> Self {
+        self.inner.pipeline_creation_cache_control = pipeline_creation_cache_control.into();
+        self
+    }
+    #[inline]
+    pub fn private_data(mut self, private_data: bool) -> Self {
+        self.inner.private_data = private_data.into();
+        self
+    }
+    #[inline]
+    pub fn shader_demote_to_helper_invocation(
+        mut self,
+        shader_demote_to_helper_invocation: bool,
+    ) -> Self {
+        self.inner.shader_demote_to_helper_invocation = shader_demote_to_helper_invocation.into();
+        self
+    }
+    #[inline]
+    pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self {
+        self.inner.shader_terminate_invocation = shader_terminate_invocation.into();
+        self
+    }
+    #[inline]
+    pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self {
+        self.inner.subgroup_size_control = subgroup_size_control.into();
+        self
+    }
+    #[inline]
+    pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self {
+        self.inner.compute_full_subgroups = compute_full_subgroups.into();
+        self
+    }
+    #[inline]
+    pub fn synchronization2(mut self, synchronization2: bool) -> Self {
+        self.inner.synchronization2 = synchronization2.into();
+        self
+    }
+    #[inline]
+    pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self {
+        self.inner.texture_compression_astc_hdr = texture_compression_astc_hdr.into();
+        self
+    }
+    #[inline]
+    pub fn shader_zero_initialize_workgroup_memory(
+        mut self,
+        shader_zero_initialize_workgroup_memory: bool,
+    ) -> Self {
+        self.inner.shader_zero_initialize_workgroup_memory =
+            shader_zero_initialize_workgroup_memory.into();
+        self
+    }
+    #[inline]
+    pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self {
+        self.inner.dynamic_rendering = dynamic_rendering.into();
+        self
+    }
+    #[inline]
+    pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self {
+        self.inner.shader_integer_dot_product = shader_integer_dot_product.into();
+        self
+    }
+    #[inline]
+    pub fn maintenance4(mut self, maintenance4: bool) -> Self {
+        self.inner.maintenance4 = maintenance4.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceVulkan13Features {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVulkan13Properties.html>"]
+pub struct PhysicalDeviceVulkan13Properties {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub min_subgroup_size: u32,
+    pub max_subgroup_size: u32,
+    pub max_compute_workgroup_subgroups: u32,
+    pub required_subgroup_size_stages: ShaderStageFlags,
+    pub max_inline_uniform_block_size: u32,
+    pub max_per_stage_descriptor_inline_uniform_blocks: u32,
+    pub max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
+    pub max_descriptor_set_inline_uniform_blocks: u32,
+    pub max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
+    pub max_inline_uniform_total_size: u32,
+    pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
+    pub integer_dot_product8_bit_signed_accelerated: Bool32,
+    pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32,
+    pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32,
+    pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32,
+    pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32,
+    pub integer_dot_product16_bit_unsigned_accelerated: Bool32,
+    pub integer_dot_product16_bit_signed_accelerated: Bool32,
+    pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32,
+    pub integer_dot_product32_bit_unsigned_accelerated: Bool32,
+    pub integer_dot_product32_bit_signed_accelerated: Bool32,
+    pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32,
+    pub integer_dot_product64_bit_unsigned_accelerated: Bool32,
+    pub integer_dot_product64_bit_signed_accelerated: Bool32,
+    pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated:
+        Bool32,
+    pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
+    pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
+    pub storage_texel_buffer_offset_alignment_bytes: DeviceSize,
+    pub storage_texel_buffer_offset_single_texel_alignment: Bool32,
+    pub uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
+    pub uniform_texel_buffer_offset_single_texel_alignment: Bool32,
+    pub max_buffer_size: DeviceSize,
+}
+impl ::std::default::Default for PhysicalDeviceVulkan13Properties {
+    #[inline]
+    fn default() -> Self {
+        Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , min_subgroup_size : u32 :: default () , max_subgroup_size : u32 :: default () , max_compute_workgroup_subgroups : u32 :: default () , required_subgroup_size_stages : ShaderStageFlags :: default () , max_inline_uniform_block_size : u32 :: default () , max_per_stage_descriptor_inline_uniform_blocks : u32 :: default () , max_per_stage_descriptor_update_after_bind_inline_uniform_blocks : u32 :: default () , max_descriptor_set_inline_uniform_blocks : u32 :: default () , max_descriptor_set_update_after_bind_inline_uniform_blocks : u32 :: default () , max_inline_uniform_total_size : u32 :: default () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , storage_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , storage_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , uniform_texel_buffer_offset_alignment_bytes : DeviceSize :: default () , uniform_texel_buffer_offset_single_texel_alignment : Bool32 :: default () , max_buffer_size : DeviceSize :: default () }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceVulkan13Properties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES;
+}
+impl PhysicalDeviceVulkan13Properties {
+    pub fn builder<'a>() -> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
+        PhysicalDeviceVulkan13PropertiesBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceVulkan13PropertiesBuilder<'a> {
+    inner: PhysicalDeviceVulkan13Properties,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13PropertiesBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceVulkan13Properties {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
+    type Target = PhysicalDeviceVulkan13Properties;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceVulkan13PropertiesBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceVulkan13PropertiesBuilder<'a> {
+    #[inline]
+    pub fn min_subgroup_size(mut self, min_subgroup_size: u32) -> Self {
+        self.inner.min_subgroup_size = min_subgroup_size;
+        self
+    }
+    #[inline]
+    pub fn max_subgroup_size(mut self, max_subgroup_size: u32) -> Self {
+        self.inner.max_subgroup_size = max_subgroup_size;
+        self
+    }
+    #[inline]
+    pub fn max_compute_workgroup_subgroups(mut self, max_compute_workgroup_subgroups: u32) -> Self {
+        self.inner.max_compute_workgroup_subgroups = max_compute_workgroup_subgroups;
+        self
+    }
+    #[inline]
+    pub fn required_subgroup_size_stages(
+        mut self,
+        required_subgroup_size_stages: ShaderStageFlags,
+    ) -> Self {
+        self.inner.required_subgroup_size_stages = required_subgroup_size_stages;
+        self
+    }
+    #[inline]
+    pub fn max_inline_uniform_block_size(mut self, max_inline_uniform_block_size: u32) -> Self {
+        self.inner.max_inline_uniform_block_size = max_inline_uniform_block_size;
+        self
+    }
+    #[inline]
+    pub fn max_per_stage_descriptor_inline_uniform_blocks(
+        mut self,
+        max_per_stage_descriptor_inline_uniform_blocks: u32,
+    ) -> Self {
+        self.inner.max_per_stage_descriptor_inline_uniform_blocks =
+            max_per_stage_descriptor_inline_uniform_blocks;
+        self
+    }
+    #[inline]
+    pub fn max_per_stage_descriptor_update_after_bind_inline_uniform_blocks(
+        mut self,
+        max_per_stage_descriptor_update_after_bind_inline_uniform_blocks: u32,
+    ) -> Self {
+        self.inner
+            .max_per_stage_descriptor_update_after_bind_inline_uniform_blocks =
+            max_per_stage_descriptor_update_after_bind_inline_uniform_blocks;
+        self
+    }
+    #[inline]
+    pub fn max_descriptor_set_inline_uniform_blocks(
+        mut self,
+        max_descriptor_set_inline_uniform_blocks: u32,
+    ) -> Self {
+        self.inner.max_descriptor_set_inline_uniform_blocks =
+            max_descriptor_set_inline_uniform_blocks;
+        self
+    }
+    #[inline]
+    pub fn max_descriptor_set_update_after_bind_inline_uniform_blocks(
+        mut self,
+        max_descriptor_set_update_after_bind_inline_uniform_blocks: u32,
+    ) -> Self {
+        self.inner
+            .max_descriptor_set_update_after_bind_inline_uniform_blocks =
+            max_descriptor_set_update_after_bind_inline_uniform_blocks;
+        self
+    }
+    #[inline]
+    pub fn max_inline_uniform_total_size(mut self, max_inline_uniform_total_size: u32) -> Self {
+        self.inner.max_inline_uniform_total_size = max_inline_uniform_total_size;
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product8_bit_unsigned_accelerated(
+        mut self,
+        integer_dot_product8_bit_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner.integer_dot_product8_bit_unsigned_accelerated =
+            integer_dot_product8_bit_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product8_bit_signed_accelerated(
+        mut self,
+        integer_dot_product8_bit_signed_accelerated: bool,
+    ) -> Self {
+        self.inner.integer_dot_product8_bit_signed_accelerated =
+            integer_dot_product8_bit_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product8_bit_mixed_signedness_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product8_bit_mixed_signedness_accelerated =
+            integer_dot_product8_bit_mixed_signedness_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
+        mut self,
+        integer_dot_product4x8_bit_packed_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product4x8_bit_packed_unsigned_accelerated =
+            integer_dot_product4x8_bit_packed_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
+        mut self,
+        integer_dot_product4x8_bit_packed_signed_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product4x8_bit_packed_signed_accelerated =
+            integer_dot_product4x8_bit_packed_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product4x8_bit_packed_mixed_signedness_accelerated =
+            integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product16_bit_unsigned_accelerated(
+        mut self,
+        integer_dot_product16_bit_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner.integer_dot_product16_bit_unsigned_accelerated =
+            integer_dot_product16_bit_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product16_bit_signed_accelerated(
+        mut self,
+        integer_dot_product16_bit_signed_accelerated: bool,
+    ) -> Self {
+        self.inner.integer_dot_product16_bit_signed_accelerated =
+            integer_dot_product16_bit_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product16_bit_mixed_signedness_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product16_bit_mixed_signedness_accelerated =
+            integer_dot_product16_bit_mixed_signedness_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product32_bit_unsigned_accelerated(
+        mut self,
+        integer_dot_product32_bit_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner.integer_dot_product32_bit_unsigned_accelerated =
+            integer_dot_product32_bit_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product32_bit_signed_accelerated(
+        mut self,
+        integer_dot_product32_bit_signed_accelerated: bool,
+    ) -> Self {
+        self.inner.integer_dot_product32_bit_signed_accelerated =
+            integer_dot_product32_bit_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product32_bit_mixed_signedness_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product32_bit_mixed_signedness_accelerated =
+            integer_dot_product32_bit_mixed_signedness_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product64_bit_unsigned_accelerated(
+        mut self,
+        integer_dot_product64_bit_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner.integer_dot_product64_bit_unsigned_accelerated =
+            integer_dot_product64_bit_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product64_bit_signed_accelerated(
+        mut self,
+        integer_dot_product64_bit_signed_accelerated: bool,
+    ) -> Self {
+        self.inner.integer_dot_product64_bit_signed_accelerated =
+            integer_dot_product64_bit_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product64_bit_mixed_signedness_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product64_bit_mixed_signedness_accelerated =
+            integer_dot_product64_bit_mixed_signedness_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated =
+            integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating8_bit_signed_accelerated =
+            integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated =
+            integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated =
+            integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated =
+            integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool,
+    ) -> Self {
+        self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ;
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated =
+            integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating16_bit_signed_accelerated =
+            integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated =
+            integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated =
+            integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating32_bit_signed_accelerated =
+            integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated =
+            integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated =
+            integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating64_bit_signed_accelerated =
+            integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
+        mut self,
+        integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool,
+    ) -> Self {
+        self.inner
+            .integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated =
+            integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn storage_texel_buffer_offset_alignment_bytes(
+        mut self,
+        storage_texel_buffer_offset_alignment_bytes: DeviceSize,
+    ) -> Self {
+        self.inner.storage_texel_buffer_offset_alignment_bytes =
+            storage_texel_buffer_offset_alignment_bytes;
+        self
+    }
+    #[inline]
+    pub fn storage_texel_buffer_offset_single_texel_alignment(
+        mut self,
+        storage_texel_buffer_offset_single_texel_alignment: bool,
+    ) -> Self {
+        self.inner
+            .storage_texel_buffer_offset_single_texel_alignment =
+            storage_texel_buffer_offset_single_texel_alignment.into();
+        self
+    }
+    #[inline]
+    pub fn uniform_texel_buffer_offset_alignment_bytes(
+        mut self,
+        uniform_texel_buffer_offset_alignment_bytes: DeviceSize,
+    ) -> Self {
+        self.inner.uniform_texel_buffer_offset_alignment_bytes =
+            uniform_texel_buffer_offset_alignment_bytes;
+        self
+    }
+    #[inline]
+    pub fn uniform_texel_buffer_offset_single_texel_alignment(
+        mut self,
+        uniform_texel_buffer_offset_single_texel_alignment: bool,
+    ) -> Self {
+        self.inner
+            .uniform_texel_buffer_offset_single_texel_alignment =
+            uniform_texel_buffer_offset_single_texel_alignment.into();
+        self
+    }
+    #[inline]
+    pub fn max_buffer_size(mut self, max_buffer_size: DeviceSize) -> Self {
+        self.inner.max_buffer_size = max_buffer_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceVulkan13Properties {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCompilerControlCreateInfoAMD.html>"]
 pub struct PipelineCompilerControlCreateInfoAMD {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub compiler_control_flags: PipelineCompilerControlFlagsAMD,
 }
 impl ::std::default::Default for PipelineCompilerControlCreateInfoAMD {
-    fn default() -> PipelineCompilerControlCreateInfoAMD {
-        PipelineCompilerControlCreateInfoAMD {
-            s_type: StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             compiler_control_flags: PipelineCompilerControlFlagsAMD::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineCompilerControlCreateInfoAMD {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
+}
 impl PipelineCompilerControlCreateInfoAMD {
     pub fn builder<'a>() -> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
         PipelineCompilerControlCreateInfoAMDBuilder {
-            inner: PipelineCompilerControlCreateInfoAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -40579,6 +47565,7 @@ impl<'a> ::std::ops::DerefMut for PipelineCompilerControlCreateInfoAMDBuilder<'a
     }
 }
 impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
+    #[inline]
     pub fn compiler_control_flags(
         mut self,
         compiler_control_flags: PipelineCompilerControlFlagsAMD,
@@ -40594,26 +47581,32 @@ impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html>"]
 pub struct PhysicalDeviceCoherentMemoryFeaturesAMD {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub device_coherent_memory: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceCoherentMemoryFeaturesAMD {
-    fn default() -> PhysicalDeviceCoherentMemoryFeaturesAMD {
-        PhysicalDeviceCoherentMemoryFeaturesAMD {
-            s_type: StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             device_coherent_memory: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceCoherentMemoryFeaturesAMD {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
+}
 impl PhysicalDeviceCoherentMemoryFeaturesAMD {
     pub fn builder<'a>() -> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
         PhysicalDeviceCoherentMemoryFeaturesAMDBuilder {
-            inner: PhysicalDeviceCoherentMemoryFeaturesAMD::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -40639,6 +47632,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder
     }
 }
 impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
+    #[inline]
     pub fn device_coherent_memory(mut self, device_coherent_memory: bool) -> Self {
         self.inner.device_coherent_memory = device_coherent_memory.into();
         self
@@ -40652,91 +47646,101 @@ impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceToolPropertiesEXT.html>"]
-pub struct PhysicalDeviceToolPropertiesEXT {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceToolProperties.html>"]
+pub struct PhysicalDeviceToolProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub name: [c_char; MAX_EXTENSION_NAME_SIZE],
     pub version: [c_char; MAX_EXTENSION_NAME_SIZE],
-    pub purposes: ToolPurposeFlagsEXT,
+    pub purposes: ToolPurposeFlags,
     pub description: [c_char; MAX_DESCRIPTION_SIZE],
     pub layer: [c_char; MAX_EXTENSION_NAME_SIZE],
 }
-impl fmt::Debug for PhysicalDeviceToolPropertiesEXT {
+#[cfg(feature = "debug")]
+impl fmt::Debug for PhysicalDeviceToolProperties {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        fmt.debug_struct("PhysicalDeviceToolPropertiesEXT")
+        fmt.debug_struct("PhysicalDeviceToolProperties")
             .field("s_type", &self.s_type)
             .field("p_next", &self.p_next)
             .field("name", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.name.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.name.as_ptr())
             })
             .field("version", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.version.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.version.as_ptr())
             })
             .field("purposes", &self.purposes)
             .field("description", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.description.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
             })
             .field("layer", &unsafe {
-                ::std::ffi::CStr::from_ptr(self.layer.as_ptr() as *const c_char)
+                ::std::ffi::CStr::from_ptr(self.layer.as_ptr())
             })
             .finish()
     }
 }
-impl ::std::default::Default for PhysicalDeviceToolPropertiesEXT {
-    fn default() -> PhysicalDeviceToolPropertiesEXT {
-        PhysicalDeviceToolPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT,
+impl ::std::default::Default for PhysicalDeviceToolProperties {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             name: unsafe { ::std::mem::zeroed() },
             version: unsafe { ::std::mem::zeroed() },
-            purposes: ToolPurposeFlagsEXT::default(),
+            purposes: ToolPurposeFlags::default(),
             description: unsafe { ::std::mem::zeroed() },
             layer: unsafe { ::std::mem::zeroed() },
         }
     }
 }
-impl PhysicalDeviceToolPropertiesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
-        PhysicalDeviceToolPropertiesEXTBuilder {
-            inner: PhysicalDeviceToolPropertiesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceToolProperties {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_TOOL_PROPERTIES;
+}
+impl PhysicalDeviceToolProperties {
+    pub fn builder<'a>() -> PhysicalDeviceToolPropertiesBuilder<'a> {
+        PhysicalDeviceToolPropertiesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceToolPropertiesEXTBuilder<'a> {
-    inner: PhysicalDeviceToolPropertiesEXT,
+pub struct PhysicalDeviceToolPropertiesBuilder<'a> {
+    inner: PhysicalDeviceToolProperties,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesEXTBuilder<'a> {
-    type Target = PhysicalDeviceToolPropertiesEXT;
+impl<'a> ::std::ops::Deref for PhysicalDeviceToolPropertiesBuilder<'a> {
+    type Target = PhysicalDeviceToolProperties;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceToolPropertiesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceToolPropertiesBuilder<'a> {
+    #[inline]
     pub fn name(mut self, name: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
         self.inner.name = name;
         self
     }
+    #[inline]
     pub fn version(mut self, version: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
         self.inner.version = version;
         self
     }
-    pub fn purposes(mut self, purposes: ToolPurposeFlagsEXT) -> Self {
+    #[inline]
+    pub fn purposes(mut self, purposes: ToolPurposeFlags) -> Self {
         self.inner.purposes = purposes;
         self
     }
+    #[inline]
     pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
         self.inner.description = description;
         self
     }
+    #[inline]
     pub fn layer(mut self, layer: [c_char; MAX_EXTENSION_NAME_SIZE]) -> Self {
         self.inner.layer = layer;
         self
@@ -40744,19 +47748,20 @@ impl<'a> PhysicalDeviceToolPropertiesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceToolPropertiesEXT {
+    pub fn build(self) -> PhysicalDeviceToolProperties {
         self.inner
     }
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html>"]
 pub struct SamplerCustomBorderColorCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub custom_border_color: ClearColorValue,
     pub format: Format,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("SamplerCustomBorderColorCreateInfoEXT")
@@ -40768,19 +47773,24 @@ impl fmt::Debug for SamplerCustomBorderColorCreateInfoEXT {
     }
 }
 impl ::std::default::Default for SamplerCustomBorderColorCreateInfoEXT {
-    fn default() -> SamplerCustomBorderColorCreateInfoEXT {
-        SamplerCustomBorderColorCreateInfoEXT {
-            s_type: StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             custom_border_color: ClearColorValue::default(),
             format: Format::default(),
         }
     }
 }
+unsafe impl TaggedStructure for SamplerCustomBorderColorCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT;
+}
 impl SamplerCustomBorderColorCreateInfoEXT {
     pub fn builder<'a>() -> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
         SamplerCustomBorderColorCreateInfoEXTBuilder {
-            inner: SamplerCustomBorderColorCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -40804,10 +47814,12 @@ impl<'a> ::std::ops::DerefMut for SamplerCustomBorderColorCreateInfoEXTBuilder<'
     }
 }
 impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn custom_border_color(mut self, custom_border_color: ClearColorValue) -> Self {
         self.inner.custom_border_color = custom_border_color;
         self
     }
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
@@ -40820,26 +47832,32 @@ impl<'a> SamplerCustomBorderColorCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html>"]
 pub struct PhysicalDeviceCustomBorderColorPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_custom_border_color_samplers: u32,
 }
 impl ::std::default::Default for PhysicalDeviceCustomBorderColorPropertiesEXT {
-    fn default() -> PhysicalDeviceCustomBorderColorPropertiesEXT {
-        PhysicalDeviceCustomBorderColorPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_custom_border_color_samplers: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceCustomBorderColorPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
+}
 impl PhysicalDeviceCustomBorderColorPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
         PhysicalDeviceCustomBorderColorPropertiesEXTBuilder {
-            inner: PhysicalDeviceCustomBorderColorPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -40866,6 +47884,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorPropertiesEXTBu
     }
 }
 impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn max_custom_border_color_samplers(
         mut self,
         max_custom_border_color_samplers: u32,
@@ -40881,8 +47900,9 @@ impl<'a> PhysicalDeviceCustomBorderColorPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html>"]
 pub struct PhysicalDeviceCustomBorderColorFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -40890,19 +47910,24 @@ pub struct PhysicalDeviceCustomBorderColorFeaturesEXT {
     pub custom_border_color_without_format: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceCustomBorderColorFeaturesEXT {
-    fn default() -> PhysicalDeviceCustomBorderColorFeaturesEXT {
-        PhysicalDeviceCustomBorderColorFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             custom_border_colors: Bool32::default(),
             custom_border_color_without_format: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceCustomBorderColorFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT;
+}
 impl PhysicalDeviceCustomBorderColorFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
         PhysicalDeviceCustomBorderColorFeaturesEXTBuilder {
-            inner: PhysicalDeviceCustomBorderColorFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -40931,10 +47956,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceCustomBorderColorFeaturesEXTBuil
     }
 }
 impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn custom_border_colors(mut self, custom_border_colors: bool) -> Self {
         self.inner.custom_border_colors = custom_border_colors.into();
         self
     }
+    #[inline]
     pub fn custom_border_color_without_format(
         mut self,
         custom_border_color_without_format: bool,
@@ -40950,32 +47977,183 @@ impl<'a> PhysicalDeviceCustomBorderColorFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerBorderColorComponentMappingCreateInfoEXT.html>"]
+pub struct SamplerBorderColorComponentMappingCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub components: ComponentMapping,
+    pub srgb: Bool32,
+}
+impl ::std::default::Default for SamplerBorderColorComponentMappingCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            components: ComponentMapping::default(),
+            srgb: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SamplerBorderColorComponentMappingCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT;
+}
+impl SamplerBorderColorComponentMappingCreateInfoEXT {
+    pub fn builder<'a>() -> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
+        SamplerBorderColorComponentMappingCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
+    inner: SamplerBorderColorComponentMappingCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSamplerCreateInfo
+    for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsSamplerCreateInfo for SamplerBorderColorComponentMappingCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
+    type Target = SamplerBorderColorComponentMappingCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SamplerBorderColorComponentMappingCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn components(mut self, components: ComponentMapping) -> Self {
+        self.inner.components = components;
+        self
+    }
+    #[inline]
+    pub fn srgb(mut self, srgb: bool) -> Self {
+        self.inner.srgb = srgb.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SamplerBorderColorComponentMappingCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.html>"]
+pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub border_color_swizzle: Bool32,
+    pub border_color_swizzle_from_image: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceBorderColorSwizzleFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            border_color_swizzle: Bool32::default(),
+            border_color_swizzle_from_image: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceBorderColorSwizzleFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT;
+}
+impl PhysicalDeviceBorderColorSwizzleFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
+        PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceBorderColorSwizzleFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceBorderColorSwizzleFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceBorderColorSwizzleFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceBorderColorSwizzleFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceBorderColorSwizzleFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn border_color_swizzle(mut self, border_color_swizzle: bool) -> Self {
+        self.inner.border_color_swizzle = border_color_swizzle.into();
+        self
+    }
+    #[inline]
+    pub fn border_color_swizzle_from_image(
+        mut self,
+        border_color_swizzle_from_image: bool,
+    ) -> Self {
+        self.inner.border_color_swizzle_from_image = border_color_swizzle_from_image.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceBorderColorSwizzleFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceOrHostAddressKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressKHR.html>"]
 pub union DeviceOrHostAddressKHR {
     pub device_address: DeviceAddress,
     pub host_address: *mut c_void,
 }
 impl ::std::default::Default for DeviceOrHostAddressKHR {
-    fn default() -> DeviceOrHostAddressKHR {
+    #[inline]
+    fn default() -> Self {
         unsafe { ::std::mem::zeroed() }
     }
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceOrHostAddressConstKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceOrHostAddressConstKHR.html>"]
 pub union DeviceOrHostAddressConstKHR {
     pub device_address: DeviceAddress,
     pub host_address: *const c_void,
 }
 impl ::std::default::Default for DeviceOrHostAddressConstKHR {
-    fn default() -> DeviceOrHostAddressConstKHR {
+    #[inline]
+    fn default() -> Self {
         unsafe { ::std::mem::zeroed() }
     }
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html>"]
 pub struct AccelerationStructureGeometryTrianglesDataKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -40987,6 +48165,7 @@ pub struct AccelerationStructureGeometryTrianglesDataKHR {
     pub index_data: DeviceOrHostAddressConstKHR,
     pub transform_data: DeviceOrHostAddressConstKHR,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("AccelerationStructureGeometryTrianglesDataKHR")
@@ -41003,9 +48182,10 @@ impl fmt::Debug for AccelerationStructureGeometryTrianglesDataKHR {
     }
 }
 impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR {
-    fn default() -> AccelerationStructureGeometryTrianglesDataKHR {
-        AccelerationStructureGeometryTrianglesDataKHR {
-            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             vertex_format: Format::default(),
             vertex_data: DeviceOrHostAddressConstKHR::default(),
@@ -41017,10 +48197,14 @@ impl ::std::default::Default for AccelerationStructureGeometryTrianglesDataKHR {
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureGeometryTrianglesDataKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR;
+}
 impl AccelerationStructureGeometryTrianglesDataKHR {
     pub fn builder<'a>() -> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
         AccelerationStructureGeometryTrianglesDataKHRBuilder {
-            inner: AccelerationStructureGeometryTrianglesDataKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41043,30 +48227,37 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryTrianglesDataKHRB
     }
 }
 impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
+    #[inline]
     pub fn vertex_format(mut self, vertex_format: Format) -> Self {
         self.inner.vertex_format = vertex_format;
         self
     }
+    #[inline]
     pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self {
         self.inner.vertex_data = vertex_data;
         self
     }
+    #[inline]
     pub fn vertex_stride(mut self, vertex_stride: DeviceSize) -> Self {
         self.inner.vertex_stride = vertex_stride;
         self
     }
+    #[inline]
     pub fn max_vertex(mut self, max_vertex: u32) -> Self {
         self.inner.max_vertex = max_vertex;
         self
     }
+    #[inline]
     pub fn index_type(mut self, index_type: IndexType) -> Self {
         self.inner.index_type = index_type;
         self
     }
+    #[inline]
     pub fn index_data(mut self, index_data: DeviceOrHostAddressConstKHR) -> Self {
         self.inner.index_data = index_data;
         self
     }
+    #[inline]
     pub fn transform_data(mut self, transform_data: DeviceOrHostAddressConstKHR) -> Self {
         self.inner.transform_data = transform_data;
         self
@@ -41081,10 +48272,10 @@ impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -41097,13 +48288,14 @@ impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html>"]
 pub struct AccelerationStructureGeometryAabbsDataKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub data: DeviceOrHostAddressConstKHR,
     pub stride: DeviceSize,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("AccelerationStructureGeometryAabbsDataKHR")
@@ -41115,19 +48307,24 @@ impl fmt::Debug for AccelerationStructureGeometryAabbsDataKHR {
     }
 }
 impl ::std::default::Default for AccelerationStructureGeometryAabbsDataKHR {
-    fn default() -> AccelerationStructureGeometryAabbsDataKHR {
-        AccelerationStructureGeometryAabbsDataKHR {
-            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             data: DeviceOrHostAddressConstKHR::default(),
             stride: DeviceSize::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureGeometryAabbsDataKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR;
+}
 impl AccelerationStructureGeometryAabbsDataKHR {
     pub fn builder<'a>() -> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
         AccelerationStructureGeometryAabbsDataKHRBuilder {
-            inner: AccelerationStructureGeometryAabbsDataKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41149,10 +48346,12 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryAabbsDataKHRBuild
     }
 }
 impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
+    #[inline]
     pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
         self.inner.data = data;
         self
     }
+    #[inline]
     pub fn stride(mut self, stride: DeviceSize) -> Self {
         self.inner.stride = stride;
         self
@@ -41166,13 +48365,14 @@ impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html>"]
 pub struct AccelerationStructureGeometryInstancesDataKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub array_of_pointers: Bool32,
     pub data: DeviceOrHostAddressConstKHR,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("AccelerationStructureGeometryInstancesDataKHR")
@@ -41184,19 +48384,24 @@ impl fmt::Debug for AccelerationStructureGeometryInstancesDataKHR {
     }
 }
 impl ::std::default::Default for AccelerationStructureGeometryInstancesDataKHR {
-    fn default() -> AccelerationStructureGeometryInstancesDataKHR {
-        AccelerationStructureGeometryInstancesDataKHR {
-            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             array_of_pointers: Bool32::default(),
             data: DeviceOrHostAddressConstKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureGeometryInstancesDataKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR;
+}
 impl AccelerationStructureGeometryInstancesDataKHR {
     pub fn builder<'a>() -> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
         AccelerationStructureGeometryInstancesDataKHRBuilder {
-            inner: AccelerationStructureGeometryInstancesDataKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41218,10 +48423,12 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryInstancesDataKHRB
     }
 }
 impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
+    #[inline]
     pub fn array_of_pointers(mut self, array_of_pointers: bool) -> Self {
         self.inner.array_of_pointers = array_of_pointers.into();
         self
     }
+    #[inline]
     pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
         self.inner.data = data;
         self
@@ -41235,20 +48442,21 @@ impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryDataKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryDataKHR.html>"]
 pub union AccelerationStructureGeometryDataKHR {
     pub triangles: AccelerationStructureGeometryTrianglesDataKHR,
     pub aabbs: AccelerationStructureGeometryAabbsDataKHR,
     pub instances: AccelerationStructureGeometryInstancesDataKHR,
 }
 impl ::std::default::Default for AccelerationStructureGeometryDataKHR {
-    fn default() -> AccelerationStructureGeometryDataKHR {
+    #[inline]
+    fn default() -> Self {
         unsafe { ::std::mem::zeroed() }
     }
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryKHR.html>"]
 pub struct AccelerationStructureGeometryKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -41256,6 +48464,7 @@ pub struct AccelerationStructureGeometryKHR {
     pub geometry: AccelerationStructureGeometryDataKHR,
     pub flags: GeometryFlagsKHR,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for AccelerationStructureGeometryKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("AccelerationStructureGeometryKHR")
@@ -41268,9 +48477,10 @@ impl fmt::Debug for AccelerationStructureGeometryKHR {
     }
 }
 impl ::std::default::Default for AccelerationStructureGeometryKHR {
-    fn default() -> AccelerationStructureGeometryKHR {
-        AccelerationStructureGeometryKHR {
-            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             geometry_type: GeometryTypeKHR::default(),
             geometry: AccelerationStructureGeometryDataKHR::default(),
@@ -41278,10 +48488,13 @@ impl ::std::default::Default for AccelerationStructureGeometryKHR {
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureGeometryKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_GEOMETRY_KHR;
+}
 impl AccelerationStructureGeometryKHR {
     pub fn builder<'a>() -> AccelerationStructureGeometryKHRBuilder<'a> {
         AccelerationStructureGeometryKHRBuilder {
-            inner: AccelerationStructureGeometryKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41303,14 +48516,17 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryKHRBuilder<'a> {
     }
 }
 impl<'a> AccelerationStructureGeometryKHRBuilder<'a> {
+    #[inline]
     pub fn geometry_type(mut self, geometry_type: GeometryTypeKHR) -> Self {
         self.inner.geometry_type = geometry_type;
         self
     }
+    #[inline]
     pub fn geometry(mut self, geometry: AccelerationStructureGeometryDataKHR) -> Self {
         self.inner.geometry = geometry;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: GeometryFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
@@ -41324,7 +48540,7 @@ impl<'a> AccelerationStructureGeometryKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html>"]
 pub struct AccelerationStructureBuildGeometryInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -41338,6 +48554,7 @@ pub struct AccelerationStructureBuildGeometryInfoKHR {
     pub pp_geometries: *const *const AccelerationStructureGeometryKHR,
     pub scratch_data: DeviceOrHostAddressKHR,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("AccelerationStructureBuildGeometryInfoKHR")
@@ -41362,9 +48579,10 @@ impl fmt::Debug for AccelerationStructureBuildGeometryInfoKHR {
     }
 }
 impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR {
-    fn default() -> AccelerationStructureBuildGeometryInfoKHR {
-        AccelerationStructureBuildGeometryInfoKHR {
-            s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             ty: AccelerationStructureTypeKHR::default(),
             flags: BuildAccelerationStructureFlagsKHR::default(),
@@ -41378,10 +48596,14 @@ impl ::std::default::Default for AccelerationStructureBuildGeometryInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureBuildGeometryInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR;
+}
 impl AccelerationStructureBuildGeometryInfoKHR {
     pub fn builder<'a>() -> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
         AccelerationStructureBuildGeometryInfoKHRBuilder {
-            inner: AccelerationStructureBuildGeometryInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41403,18 +48625,22 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildGeometryInfoKHRBuild
     }
 }
 impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: BuildAccelerationStructureFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn mode(mut self, mode: BuildAccelerationStructureModeKHR) -> Self {
         self.inner.mode = mode;
         self
     }
+    #[inline]
     pub fn src_acceleration_structure(
         mut self,
         src_acceleration_structure: AccelerationStructureKHR,
@@ -41422,6 +48648,7 @@ impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
         self.inner.src_acceleration_structure = src_acceleration_structure;
         self
     }
+    #[inline]
     pub fn dst_acceleration_structure(
         mut self,
         dst_acceleration_structure: AccelerationStructureKHR,
@@ -41429,19 +48656,22 @@ impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
         self.inner.dst_acceleration_structure = dst_acceleration_structure;
         self
     }
+    #[inline]
     pub fn geometries(mut self, geometries: &'a [AccelerationStructureGeometryKHR]) -> Self {
         self.inner.geometry_count = geometries.len() as _;
         self.inner.p_geometries = geometries.as_ptr();
         self
     }
+    #[inline]
     pub fn geometries_ptrs(
         mut self,
-        geometries: &'a [&'a AccelerationStructureGeometryKHR],
+        geometries_ptrs: &'a [&'a AccelerationStructureGeometryKHR],
     ) -> Self {
-        self.inner.geometry_count = geometries.len() as _;
-        self.inner.pp_geometries = geometries.as_ptr() as *const *const _;
+        self.inner.geometry_count = geometries_ptrs.len() as _;
+        self.inner.pp_geometries = geometries_ptrs.as_ptr().cast();
         self
     }
+    #[inline]
     pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self {
         self.inner.scratch_data = scratch_data;
         self
@@ -41454,8 +48684,9 @@ impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureBuildRangeInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildRangeInfoKHR.html>"]
 pub struct AccelerationStructureBuildRangeInfoKHR {
     pub primitive_count: u32,
     pub primitive_offset: u32,
@@ -41465,7 +48696,7 @@ pub struct AccelerationStructureBuildRangeInfoKHR {
 impl AccelerationStructureBuildRangeInfoKHR {
     pub fn builder<'a>() -> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
         AccelerationStructureBuildRangeInfoKHRBuilder {
-            inner: AccelerationStructureBuildRangeInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41487,18 +48718,22 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildRangeInfoKHRBuilder<
     }
 }
 impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
+    #[inline]
     pub fn primitive_count(mut self, primitive_count: u32) -> Self {
         self.inner.primitive_count = primitive_count;
         self
     }
+    #[inline]
     pub fn primitive_offset(mut self, primitive_offset: u32) -> Self {
         self.inner.primitive_offset = primitive_offset;
         self
     }
+    #[inline]
     pub fn first_vertex(mut self, first_vertex: u32) -> Self {
         self.inner.first_vertex = first_vertex;
         self
     }
+    #[inline]
     pub fn transform_offset(mut self, transform_offset: u32) -> Self {
         self.inner.transform_offset = transform_offset;
         self
@@ -41511,8 +48746,9 @@ impl<'a> AccelerationStructureBuildRangeInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCreateInfoKHR.html>"]
 pub struct AccelerationStructureCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -41524,9 +48760,10 @@ pub struct AccelerationStructureCreateInfoKHR {
     pub device_address: DeviceAddress,
 }
 impl ::std::default::Default for AccelerationStructureCreateInfoKHR {
-    fn default() -> AccelerationStructureCreateInfoKHR {
-        AccelerationStructureCreateInfoKHR {
-            s_type: StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             create_flags: AccelerationStructureCreateFlagsKHR::default(),
             buffer: Buffer::default(),
@@ -41537,10 +48774,13 @@ impl ::std::default::Default for AccelerationStructureCreateInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_KHR;
+}
 impl AccelerationStructureCreateInfoKHR {
     pub fn builder<'a>() -> AccelerationStructureCreateInfoKHRBuilder<'a> {
         AccelerationStructureCreateInfoKHRBuilder {
-            inner: AccelerationStructureCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41563,26 +48803,32 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureCreateInfoKHRBuilder<'a>
     }
 }
 impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn create_flags(mut self, create_flags: AccelerationStructureCreateFlagsKHR) -> Self {
         self.inner.create_flags = create_flags;
         self
     }
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
     }
+    #[inline]
     pub fn ty(mut self, ty: AccelerationStructureTypeKHR) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
         self.inner.device_address = device_address;
         self
@@ -41597,10 +48843,10 @@ impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -41612,8 +48858,9 @@ impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAabbPositionsKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAabbPositionsKHR.html>"]
 pub struct AabbPositionsKHR {
     pub min_x: f32,
     pub min_y: f32,
@@ -41625,7 +48872,7 @@ pub struct AabbPositionsKHR {
 impl AabbPositionsKHR {
     pub fn builder<'a>() -> AabbPositionsKHRBuilder<'a> {
         AabbPositionsKHRBuilder {
-            inner: AabbPositionsKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41647,26 +48894,32 @@ impl<'a> ::std::ops::DerefMut for AabbPositionsKHRBuilder<'a> {
     }
 }
 impl<'a> AabbPositionsKHRBuilder<'a> {
+    #[inline]
     pub fn min_x(mut self, min_x: f32) -> Self {
         self.inner.min_x = min_x;
         self
     }
+    #[inline]
     pub fn min_y(mut self, min_y: f32) -> Self {
         self.inner.min_y = min_y;
         self
     }
+    #[inline]
     pub fn min_z(mut self, min_z: f32) -> Self {
         self.inner.min_z = min_z;
         self
     }
+    #[inline]
     pub fn max_x(mut self, max_x: f32) -> Self {
         self.inner.max_x = max_x;
         self
     }
+    #[inline]
     pub fn max_y(mut self, max_y: f32) -> Self {
         self.inner.max_y = max_y;
         self
     }
+    #[inline]
     pub fn max_z(mut self, max_z: f32) -> Self {
         self.inner.max_z = max_z;
         self
@@ -41691,34 +48944,42 @@ pub union AccelerationStructureReferenceKHR {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureInstanceKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInstanceKHR.html>"]
 pub struct AccelerationStructureInstanceKHR {
     pub transform: TransformMatrixKHR,
-    pub instance_custom_index_and_mask: u32,
-    pub instance_shader_binding_table_record_offset_and_flags: u32,
+    #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
+    pub instance_custom_index_and_mask: Packed24_8,
+    #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
+    pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
     pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html>"]
 pub struct AccelerationStructureDeviceAddressInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub acceleration_structure: AccelerationStructureKHR,
 }
 impl ::std::default::Default for AccelerationStructureDeviceAddressInfoKHR {
-    fn default() -> AccelerationStructureDeviceAddressInfoKHR {
-        AccelerationStructureDeviceAddressInfoKHR {
-            s_type: StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             acceleration_structure: AccelerationStructureKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureDeviceAddressInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR;
+}
 impl AccelerationStructureDeviceAddressInfoKHR {
     pub fn builder<'a>() -> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
         AccelerationStructureDeviceAddressInfoKHRBuilder {
-            inner: AccelerationStructureDeviceAddressInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41740,6 +49001,7 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureDeviceAddressInfoKHRBuild
     }
 }
 impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
+    #[inline]
     pub fn acceleration_structure(
         mut self,
         acceleration_structure: AccelerationStructureKHR,
@@ -41755,26 +49017,31 @@ impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureVersionInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureVersionInfoKHR.html>"]
 pub struct AccelerationStructureVersionInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub p_version_data: *const [u8; 2 * UUID_SIZE],
 }
 impl ::std::default::Default for AccelerationStructureVersionInfoKHR {
-    fn default() -> AccelerationStructureVersionInfoKHR {
-        AccelerationStructureVersionInfoKHR {
-            s_type: StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_version_data: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureVersionInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_VERSION_INFO_KHR;
+}
 impl AccelerationStructureVersionInfoKHR {
     pub fn builder<'a>() -> AccelerationStructureVersionInfoKHRBuilder<'a> {
         AccelerationStructureVersionInfoKHRBuilder {
-            inner: AccelerationStructureVersionInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41796,8 +49063,9 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureVersionInfoKHRBuilder<'a>
     }
 }
 impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> {
+    #[inline]
     pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self {
-        self.inner.p_version_data = version_data as *const [u8; 2 * UUID_SIZE];
+        self.inner.p_version_data = version_data;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -41808,8 +49076,9 @@ impl<'a> AccelerationStructureVersionInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyAccelerationStructureInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureInfoKHR.html>"]
 pub struct CopyAccelerationStructureInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -41818,9 +49087,10 @@ pub struct CopyAccelerationStructureInfoKHR {
     pub mode: CopyAccelerationStructureModeKHR,
 }
 impl ::std::default::Default for CopyAccelerationStructureInfoKHR {
-    fn default() -> CopyAccelerationStructureInfoKHR {
-        CopyAccelerationStructureInfoKHR {
-            s_type: StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src: AccelerationStructureKHR::default(),
             dst: AccelerationStructureKHR::default(),
@@ -41828,10 +49098,13 @@ impl ::std::default::Default for CopyAccelerationStructureInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for CopyAccelerationStructureInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_ACCELERATION_STRUCTURE_INFO_KHR;
+}
 impl CopyAccelerationStructureInfoKHR {
     pub fn builder<'a>() -> CopyAccelerationStructureInfoKHRBuilder<'a> {
         CopyAccelerationStructureInfoKHRBuilder {
-            inner: CopyAccelerationStructureInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41853,14 +49126,17 @@ impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureInfoKHRBuilder<'a> {
     }
 }
 impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> {
+    #[inline]
     pub fn src(mut self, src: AccelerationStructureKHR) -> Self {
         self.inner.src = src;
         self
     }
+    #[inline]
     pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self {
         self.inner.dst = dst;
         self
     }
+    #[inline]
     pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
         self.inner.mode = mode;
         self
@@ -41874,7 +49150,7 @@ impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html>"]
 pub struct CopyAccelerationStructureToMemoryInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -41882,6 +49158,7 @@ pub struct CopyAccelerationStructureToMemoryInfoKHR {
     pub dst: DeviceOrHostAddressKHR,
     pub mode: CopyAccelerationStructureModeKHR,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("CopyAccelerationStructureToMemoryInfoKHR")
@@ -41894,9 +49171,10 @@ impl fmt::Debug for CopyAccelerationStructureToMemoryInfoKHR {
     }
 }
 impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR {
-    fn default() -> CopyAccelerationStructureToMemoryInfoKHR {
-        CopyAccelerationStructureToMemoryInfoKHR {
-            s_type: StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src: AccelerationStructureKHR::default(),
             dst: DeviceOrHostAddressKHR::default(),
@@ -41904,10 +49182,14 @@ impl ::std::default::Default for CopyAccelerationStructureToMemoryInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for CopyAccelerationStructureToMemoryInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR;
+}
 impl CopyAccelerationStructureToMemoryInfoKHR {
     pub fn builder<'a>() -> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
         CopyAccelerationStructureToMemoryInfoKHRBuilder {
-            inner: CopyAccelerationStructureToMemoryInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -41929,14 +49211,17 @@ impl<'a> ::std::ops::DerefMut for CopyAccelerationStructureToMemoryInfoKHRBuilde
     }
 }
 impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
+    #[inline]
     pub fn src(mut self, src: AccelerationStructureKHR) -> Self {
         self.inner.src = src;
         self
     }
+    #[inline]
     pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self {
         self.inner.dst = dst;
         self
     }
+    #[inline]
     pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
         self.inner.mode = mode;
         self
@@ -41950,7 +49235,7 @@ impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html>"]
 pub struct CopyMemoryToAccelerationStructureInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -41958,6 +49243,7 @@ pub struct CopyMemoryToAccelerationStructureInfoKHR {
     pub dst: AccelerationStructureKHR,
     pub mode: CopyAccelerationStructureModeKHR,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("CopyMemoryToAccelerationStructureInfoKHR")
@@ -41970,9 +49256,10 @@ impl fmt::Debug for CopyMemoryToAccelerationStructureInfoKHR {
     }
 }
 impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR {
-    fn default() -> CopyMemoryToAccelerationStructureInfoKHR {
-        CopyMemoryToAccelerationStructureInfoKHR {
-            s_type: StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src: DeviceOrHostAddressConstKHR::default(),
             dst: AccelerationStructureKHR::default(),
@@ -41980,10 +49267,14 @@ impl ::std::default::Default for CopyMemoryToAccelerationStructureInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for CopyMemoryToAccelerationStructureInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR;
+}
 impl CopyMemoryToAccelerationStructureInfoKHR {
     pub fn builder<'a>() -> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
         CopyMemoryToAccelerationStructureInfoKHRBuilder {
-            inner: CopyMemoryToAccelerationStructureInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42005,14 +49296,17 @@ impl<'a> ::std::ops::DerefMut for CopyMemoryToAccelerationStructureInfoKHRBuilde
     }
 }
 impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
+    #[inline]
     pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self {
         self.inner.src = src;
         self
     }
+    #[inline]
     pub fn dst(mut self, dst: AccelerationStructureKHR) -> Self {
         self.inner.dst = dst;
         self
     }
+    #[inline]
     pub fn mode(mut self, mode: CopyAccelerationStructureModeKHR) -> Self {
         self.inner.mode = mode;
         self
@@ -42025,8 +49319,9 @@ impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html>"]
 pub struct RayTracingPipelineInterfaceCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -42034,19 +49329,24 @@ pub struct RayTracingPipelineInterfaceCreateInfoKHR {
     pub max_pipeline_ray_hit_attribute_size: u32,
 }
 impl ::std::default::Default for RayTracingPipelineInterfaceCreateInfoKHR {
-    fn default() -> RayTracingPipelineInterfaceCreateInfoKHR {
-        RayTracingPipelineInterfaceCreateInfoKHR {
-            s_type: StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             max_pipeline_ray_payload_size: u32::default(),
             max_pipeline_ray_hit_attribute_size: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for RayTracingPipelineInterfaceCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR;
+}
 impl RayTracingPipelineInterfaceCreateInfoKHR {
     pub fn builder<'a>() -> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
         RayTracingPipelineInterfaceCreateInfoKHRBuilder {
-            inner: RayTracingPipelineInterfaceCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42068,10 +49368,12 @@ impl<'a> ::std::ops::DerefMut for RayTracingPipelineInterfaceCreateInfoKHRBuilde
     }
 }
 impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn max_pipeline_ray_payload_size(mut self, max_pipeline_ray_payload_size: u32) -> Self {
         self.inner.max_pipeline_ray_payload_size = max_pipeline_ray_payload_size;
         self
     }
+    #[inline]
     pub fn max_pipeline_ray_hit_attribute_size(
         mut self,
         max_pipeline_ray_hit_attribute_size: u32,
@@ -42087,8 +49389,9 @@ impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineLibraryCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineLibraryCreateInfoKHR.html>"]
 pub struct PipelineLibraryCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -42096,19 +49399,23 @@ pub struct PipelineLibraryCreateInfoKHR {
     pub p_libraries: *const Pipeline,
 }
 impl ::std::default::Default for PipelineLibraryCreateInfoKHR {
-    fn default() -> PipelineLibraryCreateInfoKHR {
-        PipelineLibraryCreateInfoKHR {
-            s_type: StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             library_count: u32::default(),
             p_libraries: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineLibraryCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_LIBRARY_CREATE_INFO_KHR;
+}
 impl PipelineLibraryCreateInfoKHR {
     pub fn builder<'a>() -> PipelineLibraryCreateInfoKHRBuilder<'a> {
         PipelineLibraryCreateInfoKHRBuilder {
-            inner: PipelineLibraryCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42118,6 +49425,8 @@ pub struct PipelineLibraryCreateInfoKHRBuilder<'a> {
     inner: PipelineLibraryCreateInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineLibraryCreateInfoKHRBuilder<'_> {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineLibraryCreateInfoKHR {}
 impl<'a> ::std::ops::Deref for PipelineLibraryCreateInfoKHRBuilder<'a> {
     type Target = PipelineLibraryCreateInfoKHR;
     fn deref(&self) -> &Self::Target {
@@ -42130,6 +49439,7 @@ impl<'a> ::std::ops::DerefMut for PipelineLibraryCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn libraries(mut self, libraries: &'a [Pipeline]) -> Self {
         self.inner.library_count = libraries.len() as _;
         self.inner.p_libraries = libraries.as_ptr();
@@ -42143,26 +49453,32 @@ impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html>"]
 pub struct PhysicalDeviceExtendedDynamicStateFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub extended_dynamic_state: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceExtendedDynamicStateFeaturesEXT {
-    fn default() -> PhysicalDeviceExtendedDynamicStateFeaturesEXT {
-        PhysicalDeviceExtendedDynamicStateFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             extended_dynamic_state: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicStateFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+}
 impl PhysicalDeviceExtendedDynamicStateFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
         PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder {
-            inner: PhysicalDeviceExtendedDynamicStateFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42191,6 +49507,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicStateFeaturesEXTB
     }
 }
 impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn extended_dynamic_state(mut self, extended_dynamic_state: bool) -> Self {
         self.inner.extended_dynamic_state = extended_dynamic_state.into();
         self
@@ -42203,8 +49520,9 @@ impl<'a> PhysicalDeviceExtendedDynamicStateFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html>"]
 pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -42213,9 +49531,10 @@ pub struct PhysicalDeviceExtendedDynamicState2FeaturesEXT {
     pub extended_dynamic_state2_patch_control_points: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT {
-    fn default() -> PhysicalDeviceExtendedDynamicState2FeaturesEXT {
-        PhysicalDeviceExtendedDynamicState2FeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             extended_dynamic_state2: Bool32::default(),
             extended_dynamic_state2_logic_op: Bool32::default(),
@@ -42223,10 +49542,14 @@ impl ::std::default::Default for PhysicalDeviceExtendedDynamicState2FeaturesEXT
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState2FeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT;
+}
 impl PhysicalDeviceExtendedDynamicState2FeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
         PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder {
-            inner: PhysicalDeviceExtendedDynamicState2FeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42255,10 +49578,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState2FeaturesEXT
     }
 }
 impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn extended_dynamic_state2(mut self, extended_dynamic_state2: bool) -> Self {
         self.inner.extended_dynamic_state2 = extended_dynamic_state2.into();
         self
     }
+    #[inline]
     pub fn extended_dynamic_state2_logic_op(
         mut self,
         extended_dynamic_state2_logic_op: bool,
@@ -42266,6 +49591,7 @@ impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
         self.inner.extended_dynamic_state2_logic_op = extended_dynamic_state2_logic_op.into();
         self
     }
+    #[inline]
     pub fn extended_dynamic_state2_patch_control_points(
         mut self,
         extended_dynamic_state2_patch_control_points: bool,
@@ -42282,26 +49608,649 @@ impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRenderPassTransformBeginInfoQCOM.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.html>"]
+pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub extended_dynamic_state3_tessellation_domain_origin: Bool32,
+    pub extended_dynamic_state3_depth_clamp_enable: Bool32,
+    pub extended_dynamic_state3_polygon_mode: Bool32,
+    pub extended_dynamic_state3_rasterization_samples: Bool32,
+    pub extended_dynamic_state3_sample_mask: Bool32,
+    pub extended_dynamic_state3_alpha_to_coverage_enable: Bool32,
+    pub extended_dynamic_state3_alpha_to_one_enable: Bool32,
+    pub extended_dynamic_state3_logic_op_enable: Bool32,
+    pub extended_dynamic_state3_color_blend_enable: Bool32,
+    pub extended_dynamic_state3_color_blend_equation: Bool32,
+    pub extended_dynamic_state3_color_write_mask: Bool32,
+    pub extended_dynamic_state3_rasterization_stream: Bool32,
+    pub extended_dynamic_state3_conservative_rasterization_mode: Bool32,
+    pub extended_dynamic_state3_extra_primitive_overestimation_size: Bool32,
+    pub extended_dynamic_state3_depth_clip_enable: Bool32,
+    pub extended_dynamic_state3_sample_locations_enable: Bool32,
+    pub extended_dynamic_state3_color_blend_advanced: Bool32,
+    pub extended_dynamic_state3_provoking_vertex_mode: Bool32,
+    pub extended_dynamic_state3_line_rasterization_mode: Bool32,
+    pub extended_dynamic_state3_line_stipple_enable: Bool32,
+    pub extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32,
+    pub extended_dynamic_state3_viewport_w_scaling_enable: Bool32,
+    pub extended_dynamic_state3_viewport_swizzle: Bool32,
+    pub extended_dynamic_state3_coverage_to_color_enable: Bool32,
+    pub extended_dynamic_state3_coverage_to_color_location: Bool32,
+    pub extended_dynamic_state3_coverage_modulation_mode: Bool32,
+    pub extended_dynamic_state3_coverage_modulation_table_enable: Bool32,
+    pub extended_dynamic_state3_coverage_modulation_table: Bool32,
+    pub extended_dynamic_state3_coverage_reduction_mode: Bool32,
+    pub extended_dynamic_state3_representative_fragment_test_enable: Bool32,
+    pub extended_dynamic_state3_shading_rate_image_enable: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3FeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            extended_dynamic_state3_tessellation_domain_origin: Bool32::default(),
+            extended_dynamic_state3_depth_clamp_enable: Bool32::default(),
+            extended_dynamic_state3_polygon_mode: Bool32::default(),
+            extended_dynamic_state3_rasterization_samples: Bool32::default(),
+            extended_dynamic_state3_sample_mask: Bool32::default(),
+            extended_dynamic_state3_alpha_to_coverage_enable: Bool32::default(),
+            extended_dynamic_state3_alpha_to_one_enable: Bool32::default(),
+            extended_dynamic_state3_logic_op_enable: Bool32::default(),
+            extended_dynamic_state3_color_blend_enable: Bool32::default(),
+            extended_dynamic_state3_color_blend_equation: Bool32::default(),
+            extended_dynamic_state3_color_write_mask: Bool32::default(),
+            extended_dynamic_state3_rasterization_stream: Bool32::default(),
+            extended_dynamic_state3_conservative_rasterization_mode: Bool32::default(),
+            extended_dynamic_state3_extra_primitive_overestimation_size: Bool32::default(),
+            extended_dynamic_state3_depth_clip_enable: Bool32::default(),
+            extended_dynamic_state3_sample_locations_enable: Bool32::default(),
+            extended_dynamic_state3_color_blend_advanced: Bool32::default(),
+            extended_dynamic_state3_provoking_vertex_mode: Bool32::default(),
+            extended_dynamic_state3_line_rasterization_mode: Bool32::default(),
+            extended_dynamic_state3_line_stipple_enable: Bool32::default(),
+            extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32::default(),
+            extended_dynamic_state3_viewport_w_scaling_enable: Bool32::default(),
+            extended_dynamic_state3_viewport_swizzle: Bool32::default(),
+            extended_dynamic_state3_coverage_to_color_enable: Bool32::default(),
+            extended_dynamic_state3_coverage_to_color_location: Bool32::default(),
+            extended_dynamic_state3_coverage_modulation_mode: Bool32::default(),
+            extended_dynamic_state3_coverage_modulation_table_enable: Bool32::default(),
+            extended_dynamic_state3_coverage_modulation_table: Bool32::default(),
+            extended_dynamic_state3_coverage_reduction_mode: Bool32::default(),
+            extended_dynamic_state3_representative_fragment_test_enable: Bool32::default(),
+            extended_dynamic_state3_shading_rate_image_enable: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState3FeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT;
+}
+impl PhysicalDeviceExtendedDynamicState3FeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
+        PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceExtendedDynamicState3FeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState3FeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceExtendedDynamicState3FeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceExtendedDynamicState3FeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn extended_dynamic_state3_tessellation_domain_origin(
+        mut self,
+        extended_dynamic_state3_tessellation_domain_origin: bool,
+    ) -> Self {
+        self.inner
+            .extended_dynamic_state3_tessellation_domain_origin =
+            extended_dynamic_state3_tessellation_domain_origin.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_depth_clamp_enable(
+        mut self,
+        extended_dynamic_state3_depth_clamp_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_depth_clamp_enable =
+            extended_dynamic_state3_depth_clamp_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_polygon_mode(
+        mut self,
+        extended_dynamic_state3_polygon_mode: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_polygon_mode =
+            extended_dynamic_state3_polygon_mode.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_rasterization_samples(
+        mut self,
+        extended_dynamic_state3_rasterization_samples: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_rasterization_samples =
+            extended_dynamic_state3_rasterization_samples.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_sample_mask(
+        mut self,
+        extended_dynamic_state3_sample_mask: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_sample_mask = extended_dynamic_state3_sample_mask.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_alpha_to_coverage_enable(
+        mut self,
+        extended_dynamic_state3_alpha_to_coverage_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_alpha_to_coverage_enable =
+            extended_dynamic_state3_alpha_to_coverage_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_alpha_to_one_enable(
+        mut self,
+        extended_dynamic_state3_alpha_to_one_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_alpha_to_one_enable =
+            extended_dynamic_state3_alpha_to_one_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_logic_op_enable(
+        mut self,
+        extended_dynamic_state3_logic_op_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_logic_op_enable =
+            extended_dynamic_state3_logic_op_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_color_blend_enable(
+        mut self,
+        extended_dynamic_state3_color_blend_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_color_blend_enable =
+            extended_dynamic_state3_color_blend_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_color_blend_equation(
+        mut self,
+        extended_dynamic_state3_color_blend_equation: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_color_blend_equation =
+            extended_dynamic_state3_color_blend_equation.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_color_write_mask(
+        mut self,
+        extended_dynamic_state3_color_write_mask: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_color_write_mask =
+            extended_dynamic_state3_color_write_mask.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_rasterization_stream(
+        mut self,
+        extended_dynamic_state3_rasterization_stream: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_rasterization_stream =
+            extended_dynamic_state3_rasterization_stream.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_conservative_rasterization_mode(
+        mut self,
+        extended_dynamic_state3_conservative_rasterization_mode: bool,
+    ) -> Self {
+        self.inner
+            .extended_dynamic_state3_conservative_rasterization_mode =
+            extended_dynamic_state3_conservative_rasterization_mode.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_extra_primitive_overestimation_size(
+        mut self,
+        extended_dynamic_state3_extra_primitive_overestimation_size: bool,
+    ) -> Self {
+        self.inner
+            .extended_dynamic_state3_extra_primitive_overestimation_size =
+            extended_dynamic_state3_extra_primitive_overestimation_size.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_depth_clip_enable(
+        mut self,
+        extended_dynamic_state3_depth_clip_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_depth_clip_enable =
+            extended_dynamic_state3_depth_clip_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_sample_locations_enable(
+        mut self,
+        extended_dynamic_state3_sample_locations_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_sample_locations_enable =
+            extended_dynamic_state3_sample_locations_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_color_blend_advanced(
+        mut self,
+        extended_dynamic_state3_color_blend_advanced: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_color_blend_advanced =
+            extended_dynamic_state3_color_blend_advanced.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_provoking_vertex_mode(
+        mut self,
+        extended_dynamic_state3_provoking_vertex_mode: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_provoking_vertex_mode =
+            extended_dynamic_state3_provoking_vertex_mode.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_line_rasterization_mode(
+        mut self,
+        extended_dynamic_state3_line_rasterization_mode: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_line_rasterization_mode =
+            extended_dynamic_state3_line_rasterization_mode.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_line_stipple_enable(
+        mut self,
+        extended_dynamic_state3_line_stipple_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_line_stipple_enable =
+            extended_dynamic_state3_line_stipple_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_depth_clip_negative_one_to_one(
+        mut self,
+        extended_dynamic_state3_depth_clip_negative_one_to_one: bool,
+    ) -> Self {
+        self.inner
+            .extended_dynamic_state3_depth_clip_negative_one_to_one =
+            extended_dynamic_state3_depth_clip_negative_one_to_one.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_viewport_w_scaling_enable(
+        mut self,
+        extended_dynamic_state3_viewport_w_scaling_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_viewport_w_scaling_enable =
+            extended_dynamic_state3_viewport_w_scaling_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_viewport_swizzle(
+        mut self,
+        extended_dynamic_state3_viewport_swizzle: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_viewport_swizzle =
+            extended_dynamic_state3_viewport_swizzle.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_coverage_to_color_enable(
+        mut self,
+        extended_dynamic_state3_coverage_to_color_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_coverage_to_color_enable =
+            extended_dynamic_state3_coverage_to_color_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_coverage_to_color_location(
+        mut self,
+        extended_dynamic_state3_coverage_to_color_location: bool,
+    ) -> Self {
+        self.inner
+            .extended_dynamic_state3_coverage_to_color_location =
+            extended_dynamic_state3_coverage_to_color_location.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_coverage_modulation_mode(
+        mut self,
+        extended_dynamic_state3_coverage_modulation_mode: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_coverage_modulation_mode =
+            extended_dynamic_state3_coverage_modulation_mode.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_coverage_modulation_table_enable(
+        mut self,
+        extended_dynamic_state3_coverage_modulation_table_enable: bool,
+    ) -> Self {
+        self.inner
+            .extended_dynamic_state3_coverage_modulation_table_enable =
+            extended_dynamic_state3_coverage_modulation_table_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_coverage_modulation_table(
+        mut self,
+        extended_dynamic_state3_coverage_modulation_table: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_coverage_modulation_table =
+            extended_dynamic_state3_coverage_modulation_table.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_coverage_reduction_mode(
+        mut self,
+        extended_dynamic_state3_coverage_reduction_mode: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_coverage_reduction_mode =
+            extended_dynamic_state3_coverage_reduction_mode.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_representative_fragment_test_enable(
+        mut self,
+        extended_dynamic_state3_representative_fragment_test_enable: bool,
+    ) -> Self {
+        self.inner
+            .extended_dynamic_state3_representative_fragment_test_enable =
+            extended_dynamic_state3_representative_fragment_test_enable.into();
+        self
+    }
+    #[inline]
+    pub fn extended_dynamic_state3_shading_rate_image_enable(
+        mut self,
+        extended_dynamic_state3_shading_rate_image_enable: bool,
+    ) -> Self {
+        self.inner.extended_dynamic_state3_shading_rate_image_enable =
+            extended_dynamic_state3_shading_rate_image_enable.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceExtendedDynamicState3FeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.html>"]
+pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub dynamic_primitive_topology_unrestricted: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3PropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            dynamic_primitive_topology_unrestricted: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceExtendedDynamicState3PropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT;
+}
+impl PhysicalDeviceExtendedDynamicState3PropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
+        PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
+    inner: PhysicalDeviceExtendedDynamicState3PropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceExtendedDynamicState3PropertiesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
+    type Target = PhysicalDeviceExtendedDynamicState3PropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceExtendedDynamicState3PropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn dynamic_primitive_topology_unrestricted(
+        mut self,
+        dynamic_primitive_topology_unrestricted: bool,
+    ) -> Self {
+        self.inner.dynamic_primitive_topology_unrestricted =
+            dynamic_primitive_topology_unrestricted.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceExtendedDynamicState3PropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorBlendEquationEXT.html>"]
+pub struct ColorBlendEquationEXT {
+    pub src_color_blend_factor: BlendFactor,
+    pub dst_color_blend_factor: BlendFactor,
+    pub color_blend_op: BlendOp,
+    pub src_alpha_blend_factor: BlendFactor,
+    pub dst_alpha_blend_factor: BlendFactor,
+    pub alpha_blend_op: BlendOp,
+}
+impl ColorBlendEquationEXT {
+    pub fn builder<'a>() -> ColorBlendEquationEXTBuilder<'a> {
+        ColorBlendEquationEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ColorBlendEquationEXTBuilder<'a> {
+    inner: ColorBlendEquationEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for ColorBlendEquationEXTBuilder<'a> {
+    type Target = ColorBlendEquationEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ColorBlendEquationEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ColorBlendEquationEXTBuilder<'a> {
+    #[inline]
+    pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self {
+        self.inner.src_color_blend_factor = src_color_blend_factor;
+        self
+    }
+    #[inline]
+    pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self {
+        self.inner.dst_color_blend_factor = dst_color_blend_factor;
+        self
+    }
+    #[inline]
+    pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self {
+        self.inner.color_blend_op = color_blend_op;
+        self
+    }
+    #[inline]
+    pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self {
+        self.inner.src_alpha_blend_factor = src_alpha_blend_factor;
+        self
+    }
+    #[inline]
+    pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self {
+        self.inner.dst_alpha_blend_factor = dst_alpha_blend_factor;
+        self
+    }
+    #[inline]
+    pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self {
+        self.inner.alpha_blend_op = alpha_blend_op;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ColorBlendEquationEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorBlendAdvancedEXT.html>"]
+pub struct ColorBlendAdvancedEXT {
+    pub advanced_blend_op: BlendOp,
+    pub src_premultiplied: Bool32,
+    pub dst_premultiplied: Bool32,
+    pub blend_overlap: BlendOverlapEXT,
+    pub clamp_results: Bool32,
+}
+impl ColorBlendAdvancedEXT {
+    pub fn builder<'a>() -> ColorBlendAdvancedEXTBuilder<'a> {
+        ColorBlendAdvancedEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ColorBlendAdvancedEXTBuilder<'a> {
+    inner: ColorBlendAdvancedEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for ColorBlendAdvancedEXTBuilder<'a> {
+    type Target = ColorBlendAdvancedEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ColorBlendAdvancedEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ColorBlendAdvancedEXTBuilder<'a> {
+    #[inline]
+    pub fn advanced_blend_op(mut self, advanced_blend_op: BlendOp) -> Self {
+        self.inner.advanced_blend_op = advanced_blend_op;
+        self
+    }
+    #[inline]
+    pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self {
+        self.inner.src_premultiplied = src_premultiplied.into();
+        self
+    }
+    #[inline]
+    pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self {
+        self.inner.dst_premultiplied = dst_premultiplied.into();
+        self
+    }
+    #[inline]
+    pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self {
+        self.inner.blend_overlap = blend_overlap;
+        self
+    }
+    #[inline]
+    pub fn clamp_results(mut self, clamp_results: bool) -> Self {
+        self.inner.clamp_results = clamp_results.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ColorBlendAdvancedEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassTransformBeginInfoQCOM.html>"]
 pub struct RenderPassTransformBeginInfoQCOM {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub transform: SurfaceTransformFlagsKHR,
 }
 impl ::std::default::Default for RenderPassTransformBeginInfoQCOM {
-    fn default() -> RenderPassTransformBeginInfoQCOM {
-        RenderPassTransformBeginInfoQCOM {
-            s_type: StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             transform: SurfaceTransformFlagsKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for RenderPassTransformBeginInfoQCOM {
+    const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM;
+}
 impl RenderPassTransformBeginInfoQCOM {
     pub fn builder<'a>() -> RenderPassTransformBeginInfoQCOMBuilder<'a> {
         RenderPassTransformBeginInfoQCOMBuilder {
-            inner: RenderPassTransformBeginInfoQCOM::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42325,6 +50274,7 @@ impl<'a> ::std::ops::DerefMut for RenderPassTransformBeginInfoQCOMBuilder<'a> {
     }
 }
 impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> {
+    #[inline]
     pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
         self.inner.transform = transform;
         self
@@ -42337,26 +50287,31 @@ impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyCommandTransformInfoQCOM.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyCommandTransformInfoQCOM.html>"]
 pub struct CopyCommandTransformInfoQCOM {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub transform: SurfaceTransformFlagsKHR,
 }
 impl ::std::default::Default for CopyCommandTransformInfoQCOM {
-    fn default() -> CopyCommandTransformInfoQCOM {
-        CopyCommandTransformInfoQCOM {
-            s_type: StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             transform: SurfaceTransformFlagsKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for CopyCommandTransformInfoQCOM {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_COMMAND_TRANSFORM_INFO_QCOM;
+}
 impl CopyCommandTransformInfoQCOM {
     pub fn builder<'a>() -> CopyCommandTransformInfoQCOMBuilder<'a> {
         CopyCommandTransformInfoQCOMBuilder {
-            inner: CopyCommandTransformInfoQCOM::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42366,10 +50321,10 @@ pub struct CopyCommandTransformInfoQCOMBuilder<'a> {
     inner: CopyCommandTransformInfoQCOM,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsBufferImageCopy2KHR for CopyCommandTransformInfoQCOMBuilder<'_> {}
-unsafe impl ExtendsBufferImageCopy2KHR for CopyCommandTransformInfoQCOM {}
-unsafe impl ExtendsImageBlit2KHR for CopyCommandTransformInfoQCOMBuilder<'_> {}
-unsafe impl ExtendsImageBlit2KHR for CopyCommandTransformInfoQCOM {}
+unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOMBuilder<'_> {}
+unsafe impl ExtendsBufferImageCopy2 for CopyCommandTransformInfoQCOM {}
+unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOMBuilder<'_> {}
+unsafe impl ExtendsImageBlit2 for CopyCommandTransformInfoQCOM {}
 impl<'a> ::std::ops::Deref for CopyCommandTransformInfoQCOMBuilder<'a> {
     type Target = CopyCommandTransformInfoQCOM;
     fn deref(&self) -> &Self::Target {
@@ -42382,6 +50337,7 @@ impl<'a> ::std::ops::DerefMut for CopyCommandTransformInfoQCOMBuilder<'a> {
     }
 }
 impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> {
+    #[inline]
     pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
         self.inner.transform = transform;
         self
@@ -42394,8 +50350,9 @@ impl<'a> CopyCommandTransformInfoQCOMBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html>"]
 pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -42403,19 +50360,24 @@ pub struct CommandBufferInheritanceRenderPassTransformInfoQCOM {
     pub render_area: Rect2D,
 }
 impl ::std::default::Default for CommandBufferInheritanceRenderPassTransformInfoQCOM {
-    fn default() -> CommandBufferInheritanceRenderPassTransformInfoQCOM {
-        CommandBufferInheritanceRenderPassTransformInfoQCOM {
-            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             transform: SurfaceTransformFlagsKHR::default(),
             render_area: Rect2D::default(),
         }
     }
 }
+unsafe impl TaggedStructure for CommandBufferInheritanceRenderPassTransformInfoQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM;
+}
 impl CommandBufferInheritanceRenderPassTransformInfoQCOM {
     pub fn builder<'a>() -> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
         CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder {
-            inner: CommandBufferInheritanceRenderPassTransformInfoQCOM::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42445,10 +50407,12 @@ impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderPassTransformInf
     }
 }
 impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
+    #[inline]
     pub fn transform(mut self, transform: SurfaceTransformFlagsKHR) -> Self {
         self.inner.transform = transform;
         self
     }
+    #[inline]
     pub fn render_area(mut self, render_area: Rect2D) -> Self {
         self.inner.render_area = render_area;
         self
@@ -42461,26 +50425,32 @@ impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html>"]
 pub struct PhysicalDeviceDiagnosticsConfigFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub diagnostics_config: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceDiagnosticsConfigFeaturesNV {
-    fn default() -> PhysicalDeviceDiagnosticsConfigFeaturesNV {
-        PhysicalDeviceDiagnosticsConfigFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             diagnostics_config: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDiagnosticsConfigFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV;
+}
 impl PhysicalDeviceDiagnosticsConfigFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
         PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder {
-            inner: PhysicalDeviceDiagnosticsConfigFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42509,6 +50479,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDiagnosticsConfigFeaturesNVBuild
     }
 }
 impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn diagnostics_config(mut self, diagnostics_config: bool) -> Self {
         self.inner.diagnostics_config = diagnostics_config.into();
         self
@@ -42521,26 +50492,31 @@ impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html>"]
 pub struct DeviceDiagnosticsConfigCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: DeviceDiagnosticsConfigFlagsNV,
 }
 impl ::std::default::Default for DeviceDiagnosticsConfigCreateInfoNV {
-    fn default() -> DeviceDiagnosticsConfigCreateInfoNV {
-        DeviceDiagnosticsConfigCreateInfoNV {
-            s_type: StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: DeviceDiagnosticsConfigFlagsNV::default(),
         }
     }
 }
+unsafe impl TaggedStructure for DeviceDiagnosticsConfigCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV;
+}
 impl DeviceDiagnosticsConfigCreateInfoNV {
     pub fn builder<'a>() -> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
         DeviceDiagnosticsConfigCreateInfoNVBuilder {
-            inner: DeviceDiagnosticsConfigCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42564,6 +50540,7 @@ impl<'a> ::std::ops::DerefMut for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a>
     }
 }
 impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: DeviceDiagnosticsConfigFlagsNV) -> Self {
         self.inner.flags = flags;
         self
@@ -42576,62 +50553,64 @@ impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.html>"]
-pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.html>"]
+pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shader_zero_initialize_workgroup_memory: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
-    fn default() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
-        PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR,
+impl ::std::default::Default for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_zero_initialize_workgroup_memory: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
-    pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
-        PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder {
-            inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR::default(),
+unsafe impl TaggedStructure for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
+}
+impl PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
+    pub fn builder<'a>() -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
+        PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
-    inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR,
+pub struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
+    inner: PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'_>
-{
-}
-unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR
+    for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_>
 {
 }
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {}
 unsafe impl ExtendsDeviceCreateInfo
-    for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'_>
+    for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'_>
 {
 }
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
-    type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
+    type Target = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut
-    for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a>
-{
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
+impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesBuilder<'a> {
+    #[inline]
     pub fn shader_zero_initialize_workgroup_memory(
         mut self,
         shader_zero_initialize_workgroup_memory: bool,
@@ -42643,32 +50622,37 @@ impl<'a> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
+    pub fn build(self) -> PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html>"]
 pub struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shader_subgroup_uniform_control_flow: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
-    fn default() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
-        PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
-            s_type:
-                StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_subgroup_uniform_control_flow: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR;
+}
 impl PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
         PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder {
-            inner: PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42707,6 +50691,7 @@ impl<'a> ::std::ops::DerefMut
     }
 }
 impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn shader_subgroup_uniform_control_flow(
         mut self,
         shader_subgroup_uniform_control_flow: bool,
@@ -42723,8 +50708,9 @@ impl<'a> PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2FeaturesEXT.html>"]
 pub struct PhysicalDeviceRobustness2FeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -42733,9 +50719,10 @@ pub struct PhysicalDeviceRobustness2FeaturesEXT {
     pub null_descriptor: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT {
-    fn default() -> PhysicalDeviceRobustness2FeaturesEXT {
-        PhysicalDeviceRobustness2FeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             robust_buffer_access2: Bool32::default(),
             robust_image_access2: Bool32::default(),
@@ -42743,10 +50730,13 @@ impl ::std::default::Default for PhysicalDeviceRobustness2FeaturesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceRobustness2FeaturesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
+}
 impl PhysicalDeviceRobustness2FeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
         PhysicalDeviceRobustness2FeaturesEXTBuilder {
-            inner: PhysicalDeviceRobustness2FeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42772,14 +50762,17 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2FeaturesEXTBuilder<'a
     }
 }
 impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn robust_buffer_access2(mut self, robust_buffer_access2: bool) -> Self {
         self.inner.robust_buffer_access2 = robust_buffer_access2.into();
         self
     }
+    #[inline]
     pub fn robust_image_access2(mut self, robust_image_access2: bool) -> Self {
         self.inner.robust_image_access2 = robust_image_access2.into();
         self
     }
+    #[inline]
     pub fn null_descriptor(mut self, null_descriptor: bool) -> Self {
         self.inner.null_descriptor = null_descriptor.into();
         self
@@ -42792,8 +50785,9 @@ impl<'a> PhysicalDeviceRobustness2FeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRobustness2PropertiesEXT.html>"]
 pub struct PhysicalDeviceRobustness2PropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -42801,19 +50795,24 @@ pub struct PhysicalDeviceRobustness2PropertiesEXT {
     pub robust_uniform_buffer_access_size_alignment: DeviceSize,
 }
 impl ::std::default::Default for PhysicalDeviceRobustness2PropertiesEXT {
-    fn default() -> PhysicalDeviceRobustness2PropertiesEXT {
-        PhysicalDeviceRobustness2PropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             robust_storage_buffer_access_size_alignment: DeviceSize::default(),
             robust_uniform_buffer_access_size_alignment: DeviceSize::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceRobustness2PropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT;
+}
 impl PhysicalDeviceRobustness2PropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
         PhysicalDeviceRobustness2PropertiesEXTBuilder {
-            inner: PhysicalDeviceRobustness2PropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42837,6 +50836,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceRobustness2PropertiesEXTBuilder<
     }
 }
 impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn robust_storage_buffer_access_size_alignment(
         mut self,
         robust_storage_buffer_access_size_alignment: DeviceSize,
@@ -42845,6 +50845,7 @@ impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
             robust_storage_buffer_access_size_alignment;
         self
     }
+    #[inline]
     pub fn robust_uniform_buffer_access_size_alignment(
         mut self,
         robust_uniform_buffer_access_size_alignment: DeviceSize,
@@ -42861,51 +50862,57 @@ impl<'a> PhysicalDeviceRobustness2PropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceImageRobustnessFeaturesEXT.html>"]
-pub struct PhysicalDeviceImageRobustnessFeaturesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageRobustnessFeatures.html>"]
+pub struct PhysicalDeviceImageRobustnessFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub robust_image_access: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceImageRobustnessFeaturesEXT {
-    fn default() -> PhysicalDeviceImageRobustnessFeaturesEXT {
-        PhysicalDeviceImageRobustnessFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT,
+impl ::std::default::Default for PhysicalDeviceImageRobustnessFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             robust_image_access: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceImageRobustnessFeaturesEXT {
-    pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
-        PhysicalDeviceImageRobustnessFeaturesEXTBuilder {
-            inner: PhysicalDeviceImageRobustnessFeaturesEXT::default(),
+unsafe impl TaggedStructure for PhysicalDeviceImageRobustnessFeatures {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
+}
+impl PhysicalDeviceImageRobustnessFeatures {
+    pub fn builder<'a>() -> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
+        PhysicalDeviceImageRobustnessFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
-    inner: PhysicalDeviceImageRobustnessFeaturesEXT,
+pub struct PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
+    inner: PhysicalDeviceImageRobustnessFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'_> {}
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesEXT {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'_> {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesEXT {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
-    type Target = PhysicalDeviceImageRobustnessFeaturesEXT;
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageRobustnessFeatures {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageRobustnessFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
+    type Target = PhysicalDeviceImageRobustnessFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
+impl<'a> PhysicalDeviceImageRobustnessFeaturesBuilder<'a> {
+    #[inline]
     pub fn robust_image_access(mut self, robust_image_access: bool) -> Self {
         self.inner.robust_image_access = robust_image_access.into();
         self
@@ -42913,13 +50920,14 @@ impl<'a> PhysicalDeviceImageRobustnessFeaturesEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceImageRobustnessFeaturesEXT {
+    pub fn build(self) -> PhysicalDeviceImageRobustnessFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html>"]
 pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -42929,9 +50937,10 @@ pub struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
     pub workgroup_memory_explicit_layout16_bit_access: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
-    fn default() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
-        PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             workgroup_memory_explicit_layout: Bool32::default(),
             workgroup_memory_explicit_layout_scalar_block_layout: Bool32::default(),
@@ -42940,10 +50949,14 @@ impl ::std::default::Default for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeat
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+}
 impl PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
         PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder {
-            inner: PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -42980,6 +50993,7 @@ impl<'a> ::std::ops::DerefMut
     }
 }
 impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn workgroup_memory_explicit_layout(
         mut self,
         workgroup_memory_explicit_layout: bool,
@@ -42987,6 +51001,7 @@ impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
         self.inner.workgroup_memory_explicit_layout = workgroup_memory_explicit_layout.into();
         self
     }
+    #[inline]
     pub fn workgroup_memory_explicit_layout_scalar_block_layout(
         mut self,
         workgroup_memory_explicit_layout_scalar_block_layout: bool,
@@ -42996,6 +51011,7 @@ impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
             workgroup_memory_explicit_layout_scalar_block_layout.into();
         self
     }
+    #[inline]
     pub fn workgroup_memory_explicit_layout8_bit_access(
         mut self,
         workgroup_memory_explicit_layout8_bit_access: bool,
@@ -43004,6 +51020,7 @@ impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
             workgroup_memory_explicit_layout8_bit_access.into();
         self
     }
+    #[inline]
     pub fn workgroup_memory_explicit_layout16_bit_access(
         mut self,
         workgroup_memory_explicit_layout16_bit_access: bool,
@@ -43020,8 +51037,9 @@ impl<'a> PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html>"]
 pub struct PhysicalDevicePortabilitySubsetFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -43042,9 +51060,10 @@ pub struct PhysicalDevicePortabilitySubsetFeaturesKHR {
     pub vertex_attribute_access_beyond_stride: Bool32,
 }
 impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR {
-    fn default() -> PhysicalDevicePortabilitySubsetFeaturesKHR {
-        PhysicalDevicePortabilitySubsetFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             constant_alpha_color_blend_factors: Bool32::default(),
             events: Bool32::default(),
@@ -43064,10 +51083,14 @@ impl ::std::default::Default for PhysicalDevicePortabilitySubsetFeaturesKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePortabilitySubsetFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR;
+}
 impl PhysicalDevicePortabilitySubsetFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
         PhysicalDevicePortabilitySubsetFeaturesKHRBuilder {
-            inner: PhysicalDevicePortabilitySubsetFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -43096,6 +51119,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetFeaturesKHRBuil
     }
 }
 impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn constant_alpha_color_blend_factors(
         mut self,
         constant_alpha_color_blend_factors: bool,
@@ -43103,10 +51127,12 @@ impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
         self.inner.constant_alpha_color_blend_factors = constant_alpha_color_blend_factors.into();
         self
     }
+    #[inline]
     pub fn events(mut self, events: bool) -> Self {
         self.inner.events = events.into();
         self
     }
+    #[inline]
     pub fn image_view_format_reinterpretation(
         mut self,
         image_view_format_reinterpretation: bool,
@@ -43114,34 +51140,42 @@ impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
         self.inner.image_view_format_reinterpretation = image_view_format_reinterpretation.into();
         self
     }
+    #[inline]
     pub fn image_view_format_swizzle(mut self, image_view_format_swizzle: bool) -> Self {
         self.inner.image_view_format_swizzle = image_view_format_swizzle.into();
         self
     }
+    #[inline]
     pub fn image_view2_d_on3_d_image(mut self, image_view2_d_on3_d_image: bool) -> Self {
         self.inner.image_view2_d_on3_d_image = image_view2_d_on3_d_image.into();
         self
     }
+    #[inline]
     pub fn multisample_array_image(mut self, multisample_array_image: bool) -> Self {
         self.inner.multisample_array_image = multisample_array_image.into();
         self
     }
+    #[inline]
     pub fn mutable_comparison_samplers(mut self, mutable_comparison_samplers: bool) -> Self {
         self.inner.mutable_comparison_samplers = mutable_comparison_samplers.into();
         self
     }
+    #[inline]
     pub fn point_polygons(mut self, point_polygons: bool) -> Self {
         self.inner.point_polygons = point_polygons.into();
         self
     }
+    #[inline]
     pub fn sampler_mip_lod_bias(mut self, sampler_mip_lod_bias: bool) -> Self {
         self.inner.sampler_mip_lod_bias = sampler_mip_lod_bias.into();
         self
     }
+    #[inline]
     pub fn separate_stencil_mask_ref(mut self, separate_stencil_mask_ref: bool) -> Self {
         self.inner.separate_stencil_mask_ref = separate_stencil_mask_ref.into();
         self
     }
+    #[inline]
     pub fn shader_sample_rate_interpolation_functions(
         mut self,
         shader_sample_rate_interpolation_functions: bool,
@@ -43150,18 +51184,22 @@ impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
             shader_sample_rate_interpolation_functions.into();
         self
     }
+    #[inline]
     pub fn tessellation_isolines(mut self, tessellation_isolines: bool) -> Self {
         self.inner.tessellation_isolines = tessellation_isolines.into();
         self
     }
+    #[inline]
     pub fn tessellation_point_mode(mut self, tessellation_point_mode: bool) -> Self {
         self.inner.tessellation_point_mode = tessellation_point_mode.into();
         self
     }
+    #[inline]
     pub fn triangle_fans(mut self, triangle_fans: bool) -> Self {
         self.inner.triangle_fans = triangle_fans.into();
         self
     }
+    #[inline]
     pub fn vertex_attribute_access_beyond_stride(
         mut self,
         vertex_attribute_access_beyond_stride: bool,
@@ -43178,26 +51216,32 @@ impl<'a> PhysicalDevicePortabilitySubsetFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html>"]
 pub struct PhysicalDevicePortabilitySubsetPropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub min_vertex_input_binding_stride_alignment: u32,
 }
 impl ::std::default::Default for PhysicalDevicePortabilitySubsetPropertiesKHR {
-    fn default() -> PhysicalDevicePortabilitySubsetPropertiesKHR {
-        PhysicalDevicePortabilitySubsetPropertiesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             min_vertex_input_binding_stride_alignment: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevicePortabilitySubsetPropertiesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR;
+}
 impl PhysicalDevicePortabilitySubsetPropertiesKHR {
     pub fn builder<'a>() -> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
         PhysicalDevicePortabilitySubsetPropertiesKHRBuilder {
-            inner: PhysicalDevicePortabilitySubsetPropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -43224,6 +51268,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevicePortabilitySubsetPropertiesKHRBu
     }
 }
 impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn min_vertex_input_binding_stride_alignment(
         mut self,
         min_vertex_input_binding_stride_alignment: u32,
@@ -43240,8 +51285,9 @@ impl<'a> PhysicalDevicePortabilitySubsetPropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html>"]
 pub struct PhysicalDevice4444FormatsFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -43249,19 +51295,23 @@ pub struct PhysicalDevice4444FormatsFeaturesEXT {
     pub format_a4b4g4r4: Bool32,
 }
 impl ::std::default::Default for PhysicalDevice4444FormatsFeaturesEXT {
-    fn default() -> PhysicalDevice4444FormatsFeaturesEXT {
-        PhysicalDevice4444FormatsFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             format_a4r4g4b4: Bool32::default(),
             format_a4b4g4r4: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDevice4444FormatsFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT;
+}
 impl PhysicalDevice4444FormatsFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
         PhysicalDevice4444FormatsFeaturesEXTBuilder {
-            inner: PhysicalDevice4444FormatsFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -43287,10 +51337,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDevice4444FormatsFeaturesEXTBuilder<'a
     }
 }
 impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn format_a4r4g4b4(mut self, format_a4r4g4b4: bool) -> Self {
         self.inner.format_a4r4g4b4 = format_a4r4g4b4.into();
         self
     }
+    #[inline]
     pub fn format_a4b4g4r4(mut self, format_a4b4g4r4: bool) -> Self {
         self.inner.format_a4b4g4r4 = format_a4b4g4r4.into();
         self
@@ -43303,26 +51355,32 @@ impl<'a> PhysicalDevice4444FormatsFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html>"]
 pub struct PhysicalDeviceSubpassShadingFeaturesHUAWEI {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub subpass_shading: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceSubpassShadingFeaturesHUAWEI {
-    fn default() -> PhysicalDeviceSubpassShadingFeaturesHUAWEI {
-        PhysicalDeviceSubpassShadingFeaturesHUAWEI {
-            s_type: StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             subpass_shading: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceSubpassShadingFeaturesHUAWEI {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI;
+}
 impl PhysicalDeviceSubpassShadingFeaturesHUAWEI {
     pub fn builder<'a>() -> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
         PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder {
-            inner: PhysicalDeviceSubpassShadingFeaturesHUAWEI::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -43351,6 +51409,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassShadingFeaturesHUAWEIBuil
     }
 }
 impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
+    #[inline]
     pub fn subpass_shading(mut self, subpass_shading: bool) -> Self {
         self.inner.subpass_shading = subpass_shading.into();
         self
@@ -43363,19 +51422,101 @@ impl<'a> PhysicalDeviceSubpassShadingFeaturesHUAWEIBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferCopy2KHR.html>"]
-pub struct BufferCopy2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.html>"]
+pub struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub clusterculling_shader: Bool32,
+    pub multiview_cluster_culling_shader: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            clusterculling_shader: Bool32::default(),
+            multiview_cluster_culling_shader: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI;
+}
+impl PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
+    pub fn builder<'a>() -> PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
+        PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
+    inner: PhysicalDeviceClusterCullingShaderFeaturesHUAWEI,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
+    type Target = PhysicalDeviceClusterCullingShaderFeaturesHUAWEI;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceClusterCullingShaderFeaturesHUAWEIBuilder<'a> {
+    #[inline]
+    pub fn clusterculling_shader(mut self, clusterculling_shader: bool) -> Self {
+        self.inner.clusterculling_shader = clusterculling_shader.into();
+        self
+    }
+    #[inline]
+    pub fn multiview_cluster_culling_shader(
+        mut self,
+        multiview_cluster_culling_shader: bool,
+    ) -> Self {
+        self.inner.multiview_cluster_culling_shader = multiview_cluster_culling_shader.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCopy2.html>"]
+pub struct BufferCopy2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_offset: DeviceSize,
     pub dst_offset: DeviceSize,
     pub size: DeviceSize,
 }
-impl ::std::default::Default for BufferCopy2KHR {
-    fn default() -> BufferCopy2KHR {
-        BufferCopy2KHR {
-            s_type: StructureType::BUFFER_COPY_2_KHR,
+impl ::std::default::Default for BufferCopy2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_offset: DeviceSize::default(),
             dst_offset: DeviceSize::default(),
@@ -43383,39 +51524,45 @@ impl ::std::default::Default for BufferCopy2KHR {
         }
     }
 }
-impl BufferCopy2KHR {
-    pub fn builder<'a>() -> BufferCopy2KHRBuilder<'a> {
-        BufferCopy2KHRBuilder {
-            inner: BufferCopy2KHR::default(),
+unsafe impl TaggedStructure for BufferCopy2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COPY_2;
+}
+impl BufferCopy2 {
+    pub fn builder<'a>() -> BufferCopy2Builder<'a> {
+        BufferCopy2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct BufferCopy2KHRBuilder<'a> {
-    inner: BufferCopy2KHR,
+pub struct BufferCopy2Builder<'a> {
+    inner: BufferCopy2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for BufferCopy2KHRBuilder<'a> {
-    type Target = BufferCopy2KHR;
+impl<'a> ::std::ops::Deref for BufferCopy2Builder<'a> {
+    type Target = BufferCopy2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for BufferCopy2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for BufferCopy2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> BufferCopy2KHRBuilder<'a> {
+impl<'a> BufferCopy2Builder<'a> {
+    #[inline]
     pub fn src_offset(mut self, src_offset: DeviceSize) -> Self {
         self.inner.src_offset = src_offset;
         self
     }
+    #[inline]
     pub fn dst_offset(mut self, dst_offset: DeviceSize) -> Self {
         self.inner.dst_offset = dst_offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
@@ -43423,14 +51570,15 @@ impl<'a> BufferCopy2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> BufferCopy2KHR {
+    pub fn build(self) -> BufferCopy2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageCopy2KHR.html>"]
-pub struct ImageCopy2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCopy2.html>"]
+pub struct ImageCopy2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_subresource: ImageSubresourceLayers,
@@ -43439,10 +51587,11 @@ pub struct ImageCopy2KHR {
     pub dst_offset: Offset3D,
     pub extent: Extent3D,
 }
-impl ::std::default::Default for ImageCopy2KHR {
-    fn default() -> ImageCopy2KHR {
-        ImageCopy2KHR {
-            s_type: StructureType::IMAGE_COPY_2_KHR,
+impl ::std::default::Default for ImageCopy2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_subresource: ImageSubresourceLayers::default(),
             src_offset: Offset3D::default(),
@@ -43452,47 +51601,55 @@ impl ::std::default::Default for ImageCopy2KHR {
         }
     }
 }
-impl ImageCopy2KHR {
-    pub fn builder<'a>() -> ImageCopy2KHRBuilder<'a> {
-        ImageCopy2KHRBuilder {
-            inner: ImageCopy2KHR::default(),
+unsafe impl TaggedStructure for ImageCopy2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COPY_2;
+}
+impl ImageCopy2 {
+    pub fn builder<'a>() -> ImageCopy2Builder<'a> {
+        ImageCopy2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct ImageCopy2KHRBuilder<'a> {
-    inner: ImageCopy2KHR,
+pub struct ImageCopy2Builder<'a> {
+    inner: ImageCopy2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for ImageCopy2KHRBuilder<'a> {
-    type Target = ImageCopy2KHR;
+impl<'a> ::std::ops::Deref for ImageCopy2Builder<'a> {
+    type Target = ImageCopy2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for ImageCopy2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for ImageCopy2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> ImageCopy2KHRBuilder<'a> {
+impl<'a> ImageCopy2Builder<'a> {
+    #[inline]
     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
         self.inner.src_subresource = src_subresource;
         self
     }
+    #[inline]
     pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
         self.inner.src_offset = src_offset;
         self
     }
+    #[inline]
     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
         self.inner.dst_subresource = dst_subresource;
         self
     }
+    #[inline]
     pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
         self.inner.dst_offset = dst_offset;
         self
     }
+    #[inline]
     pub fn extent(mut self, extent: Extent3D) -> Self {
         self.inner.extent = extent;
         self
@@ -43500,14 +51657,15 @@ impl<'a> ImageCopy2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> ImageCopy2KHR {
+    pub fn build(self) -> ImageCopy2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageBlit2KHR.html>"]
-pub struct ImageBlit2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageBlit2.html>"]
+pub struct ImageBlit2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_subresource: ImageSubresourceLayers,
@@ -43515,10 +51673,11 @@ pub struct ImageBlit2KHR {
     pub dst_subresource: ImageSubresourceLayers,
     pub dst_offsets: [Offset3D; 2],
 }
-impl ::std::default::Default for ImageBlit2KHR {
-    fn default() -> ImageBlit2KHR {
-        ImageBlit2KHR {
-            s_type: StructureType::IMAGE_BLIT_2_KHR,
+impl ::std::default::Default for ImageBlit2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_subresource: ImageSubresourceLayers::default(),
             src_offsets: unsafe { ::std::mem::zeroed() },
@@ -43527,44 +51686,51 @@ impl ::std::default::Default for ImageBlit2KHR {
         }
     }
 }
-impl ImageBlit2KHR {
-    pub fn builder<'a>() -> ImageBlit2KHRBuilder<'a> {
-        ImageBlit2KHRBuilder {
-            inner: ImageBlit2KHR::default(),
+unsafe impl TaggedStructure for ImageBlit2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_BLIT_2;
+}
+impl ImageBlit2 {
+    pub fn builder<'a>() -> ImageBlit2Builder<'a> {
+        ImageBlit2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct ImageBlit2KHRBuilder<'a> {
-    inner: ImageBlit2KHR,
+pub struct ImageBlit2Builder<'a> {
+    inner: ImageBlit2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-pub unsafe trait ExtendsImageBlit2KHR {}
-impl<'a> ::std::ops::Deref for ImageBlit2KHRBuilder<'a> {
-    type Target = ImageBlit2KHR;
+pub unsafe trait ExtendsImageBlit2 {}
+impl<'a> ::std::ops::Deref for ImageBlit2Builder<'a> {
+    type Target = ImageBlit2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for ImageBlit2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for ImageBlit2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> ImageBlit2KHRBuilder<'a> {
+impl<'a> ImageBlit2Builder<'a> {
+    #[inline]
     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
         self.inner.src_subresource = src_subresource;
         self
     }
+    #[inline]
     pub fn src_offsets(mut self, src_offsets: [Offset3D; 2]) -> Self {
         self.inner.src_offsets = src_offsets;
         self
     }
+    #[inline]
     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
         self.inner.dst_subresource = dst_subresource;
         self
     }
+    #[inline]
     pub fn dst_offsets(mut self, dst_offsets: [Offset3D; 2]) -> Self {
         self.inner.dst_offsets = dst_offsets;
         self
@@ -43574,26 +51740,27 @@ impl<'a> ImageBlit2KHRBuilder<'a> {
     #[doc = r" valid extension structs can be pushed into the chain."]
     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
     #[doc = r" chain will look like `A -> D -> B -> C`."]
-    pub fn push_next<T: ExtendsImageBlit2KHR>(mut self, next: &'a mut T) -> Self {
+    pub fn push_next<T: ExtendsImageBlit2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> ImageBlit2KHR {
+    pub fn build(self) -> ImageBlit2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferImageCopy2KHR.html>"]
-pub struct BufferImageCopy2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferImageCopy2.html>"]
+pub struct BufferImageCopy2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub buffer_offset: DeviceSize,
@@ -43603,10 +51770,11 @@ pub struct BufferImageCopy2KHR {
     pub image_offset: Offset3D,
     pub image_extent: Extent3D,
 }
-impl ::std::default::Default for BufferImageCopy2KHR {
-    fn default() -> BufferImageCopy2KHR {
-        BufferImageCopy2KHR {
-            s_type: StructureType::BUFFER_IMAGE_COPY_2_KHR,
+impl ::std::default::Default for BufferImageCopy2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             buffer_offset: DeviceSize::default(),
             buffer_row_length: u32::default(),
@@ -43617,52 +51785,61 @@ impl ::std::default::Default for BufferImageCopy2KHR {
         }
     }
 }
-impl BufferImageCopy2KHR {
-    pub fn builder<'a>() -> BufferImageCopy2KHRBuilder<'a> {
-        BufferImageCopy2KHRBuilder {
-            inner: BufferImageCopy2KHR::default(),
+unsafe impl TaggedStructure for BufferImageCopy2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_IMAGE_COPY_2;
+}
+impl BufferImageCopy2 {
+    pub fn builder<'a>() -> BufferImageCopy2Builder<'a> {
+        BufferImageCopy2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct BufferImageCopy2KHRBuilder<'a> {
-    inner: BufferImageCopy2KHR,
+pub struct BufferImageCopy2Builder<'a> {
+    inner: BufferImageCopy2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-pub unsafe trait ExtendsBufferImageCopy2KHR {}
-impl<'a> ::std::ops::Deref for BufferImageCopy2KHRBuilder<'a> {
-    type Target = BufferImageCopy2KHR;
+pub unsafe trait ExtendsBufferImageCopy2 {}
+impl<'a> ::std::ops::Deref for BufferImageCopy2Builder<'a> {
+    type Target = BufferImageCopy2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for BufferImageCopy2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for BufferImageCopy2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> BufferImageCopy2KHRBuilder<'a> {
+impl<'a> BufferImageCopy2Builder<'a> {
+    #[inline]
     pub fn buffer_offset(mut self, buffer_offset: DeviceSize) -> Self {
         self.inner.buffer_offset = buffer_offset;
         self
     }
+    #[inline]
     pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self {
         self.inner.buffer_row_length = buffer_row_length;
         self
     }
+    #[inline]
     pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self {
         self.inner.buffer_image_height = buffer_image_height;
         self
     }
+    #[inline]
     pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self {
         self.inner.image_subresource = image_subresource;
         self
     }
+    #[inline]
     pub fn image_offset(mut self, image_offset: Offset3D) -> Self {
         self.inner.image_offset = image_offset;
         self
     }
+    #[inline]
     pub fn image_extent(mut self, image_extent: Extent3D) -> Self {
         self.inner.image_extent = image_extent;
         self
@@ -43672,26 +51849,27 @@ impl<'a> BufferImageCopy2KHRBuilder<'a> {
     #[doc = r" valid extension structs can be pushed into the chain."]
     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
     #[doc = r" chain will look like `A -> D -> B -> C`."]
-    pub fn push_next<T: ExtendsBufferImageCopy2KHR>(mut self, next: &'a mut T) -> Self {
+    pub fn push_next<T: ExtendsBufferImageCopy2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> BufferImageCopy2KHR {
+    pub fn build(self) -> BufferImageCopy2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageResolve2KHR.html>"]
-pub struct ImageResolve2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageResolve2.html>"]
+pub struct ImageResolve2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_subresource: ImageSubresourceLayers,
@@ -43700,10 +51878,11 @@ pub struct ImageResolve2KHR {
     pub dst_offset: Offset3D,
     pub extent: Extent3D,
 }
-impl ::std::default::Default for ImageResolve2KHR {
-    fn default() -> ImageResolve2KHR {
-        ImageResolve2KHR {
-            s_type: StructureType::IMAGE_RESOLVE_2_KHR,
+impl ::std::default::Default for ImageResolve2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_subresource: ImageSubresourceLayers::default(),
             src_offset: Offset3D::default(),
@@ -43713,47 +51892,55 @@ impl ::std::default::Default for ImageResolve2KHR {
         }
     }
 }
-impl ImageResolve2KHR {
-    pub fn builder<'a>() -> ImageResolve2KHRBuilder<'a> {
-        ImageResolve2KHRBuilder {
-            inner: ImageResolve2KHR::default(),
+unsafe impl TaggedStructure for ImageResolve2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_RESOLVE_2;
+}
+impl ImageResolve2 {
+    pub fn builder<'a>() -> ImageResolve2Builder<'a> {
+        ImageResolve2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct ImageResolve2KHRBuilder<'a> {
-    inner: ImageResolve2KHR,
+pub struct ImageResolve2Builder<'a> {
+    inner: ImageResolve2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for ImageResolve2KHRBuilder<'a> {
-    type Target = ImageResolve2KHR;
+impl<'a> ::std::ops::Deref for ImageResolve2Builder<'a> {
+    type Target = ImageResolve2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for ImageResolve2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for ImageResolve2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> ImageResolve2KHRBuilder<'a> {
+impl<'a> ImageResolve2Builder<'a> {
+    #[inline]
     pub fn src_subresource(mut self, src_subresource: ImageSubresourceLayers) -> Self {
         self.inner.src_subresource = src_subresource;
         self
     }
+    #[inline]
     pub fn src_offset(mut self, src_offset: Offset3D) -> Self {
         self.inner.src_offset = src_offset;
         self
     }
+    #[inline]
     pub fn dst_subresource(mut self, dst_subresource: ImageSubresourceLayers) -> Self {
         self.inner.dst_subresource = dst_subresource;
         self
     }
+    #[inline]
     pub fn dst_offset(mut self, dst_offset: Offset3D) -> Self {
         self.inner.dst_offset = dst_offset;
         self
     }
+    #[inline]
     pub fn extent(mut self, extent: Extent3D) -> Self {
         self.inner.extent = extent;
         self
@@ -43761,25 +51948,27 @@ impl<'a> ImageResolve2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> ImageResolve2KHR {
+    pub fn build(self) -> ImageResolve2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyBufferInfo2KHR.html>"]
-pub struct CopyBufferInfo2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferInfo2.html>"]
+pub struct CopyBufferInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_buffer: Buffer,
     pub dst_buffer: Buffer,
     pub region_count: u32,
-    pub p_regions: *const BufferCopy2KHR,
+    pub p_regions: *const BufferCopy2,
 }
-impl ::std::default::Default for CopyBufferInfo2KHR {
-    fn default() -> CopyBufferInfo2KHR {
-        CopyBufferInfo2KHR {
-            s_type: StructureType::COPY_BUFFER_INFO_2_KHR,
+impl ::std::default::Default for CopyBufferInfo2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_buffer: Buffer::default(),
             dst_buffer: Buffer::default(),
@@ -43788,40 +51977,46 @@ impl ::std::default::Default for CopyBufferInfo2KHR {
         }
     }
 }
-impl CopyBufferInfo2KHR {
-    pub fn builder<'a>() -> CopyBufferInfo2KHRBuilder<'a> {
-        CopyBufferInfo2KHRBuilder {
-            inner: CopyBufferInfo2KHR::default(),
+unsafe impl TaggedStructure for CopyBufferInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_BUFFER_INFO_2;
+}
+impl CopyBufferInfo2 {
+    pub fn builder<'a>() -> CopyBufferInfo2Builder<'a> {
+        CopyBufferInfo2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct CopyBufferInfo2KHRBuilder<'a> {
-    inner: CopyBufferInfo2KHR,
+pub struct CopyBufferInfo2Builder<'a> {
+    inner: CopyBufferInfo2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for CopyBufferInfo2KHRBuilder<'a> {
-    type Target = CopyBufferInfo2KHR;
+impl<'a> ::std::ops::Deref for CopyBufferInfo2Builder<'a> {
+    type Target = CopyBufferInfo2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for CopyBufferInfo2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for CopyBufferInfo2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> CopyBufferInfo2KHRBuilder<'a> {
+impl<'a> CopyBufferInfo2Builder<'a> {
+    #[inline]
     pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
         self.inner.src_buffer = src_buffer;
         self
     }
+    #[inline]
     pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
         self.inner.dst_buffer = dst_buffer;
         self
     }
-    pub fn regions(mut self, regions: &'a [BufferCopy2KHR]) -> Self {
+    #[inline]
+    pub fn regions(mut self, regions: &'a [BufferCopy2]) -> Self {
         self.inner.region_count = regions.len() as _;
         self.inner.p_regions = regions.as_ptr();
         self
@@ -43829,14 +52024,15 @@ impl<'a> CopyBufferInfo2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> CopyBufferInfo2KHR {
+    pub fn build(self) -> CopyBufferInfo2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyImageInfo2KHR.html>"]
-pub struct CopyImageInfo2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageInfo2.html>"]
+pub struct CopyImageInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_image: Image,
@@ -43844,12 +52040,13 @@ pub struct CopyImageInfo2KHR {
     pub dst_image: Image,
     pub dst_image_layout: ImageLayout,
     pub region_count: u32,
-    pub p_regions: *const ImageCopy2KHR,
+    pub p_regions: *const ImageCopy2,
 }
-impl ::std::default::Default for CopyImageInfo2KHR {
-    fn default() -> CopyImageInfo2KHR {
-        CopyImageInfo2KHR {
-            s_type: StructureType::COPY_IMAGE_INFO_2_KHR,
+impl ::std::default::Default for CopyImageInfo2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_image: Image::default(),
             src_image_layout: ImageLayout::default(),
@@ -43860,48 +52057,56 @@ impl ::std::default::Default for CopyImageInfo2KHR {
         }
     }
 }
-impl CopyImageInfo2KHR {
-    pub fn builder<'a>() -> CopyImageInfo2KHRBuilder<'a> {
-        CopyImageInfo2KHRBuilder {
-            inner: CopyImageInfo2KHR::default(),
+unsafe impl TaggedStructure for CopyImageInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_INFO_2;
+}
+impl CopyImageInfo2 {
+    pub fn builder<'a>() -> CopyImageInfo2Builder<'a> {
+        CopyImageInfo2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct CopyImageInfo2KHRBuilder<'a> {
-    inner: CopyImageInfo2KHR,
+pub struct CopyImageInfo2Builder<'a> {
+    inner: CopyImageInfo2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for CopyImageInfo2KHRBuilder<'a> {
-    type Target = CopyImageInfo2KHR;
+impl<'a> ::std::ops::Deref for CopyImageInfo2Builder<'a> {
+    type Target = CopyImageInfo2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for CopyImageInfo2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for CopyImageInfo2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> CopyImageInfo2KHRBuilder<'a> {
+impl<'a> CopyImageInfo2Builder<'a> {
+    #[inline]
     pub fn src_image(mut self, src_image: Image) -> Self {
         self.inner.src_image = src_image;
         self
     }
+    #[inline]
     pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
         self.inner.src_image_layout = src_image_layout;
         self
     }
+    #[inline]
     pub fn dst_image(mut self, dst_image: Image) -> Self {
         self.inner.dst_image = dst_image;
         self
     }
+    #[inline]
     pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
         self.inner.dst_image_layout = dst_image_layout;
         self
     }
-    pub fn regions(mut self, regions: &'a [ImageCopy2KHR]) -> Self {
+    #[inline]
+    pub fn regions(mut self, regions: &'a [ImageCopy2]) -> Self {
         self.inner.region_count = regions.len() as _;
         self.inner.p_regions = regions.as_ptr();
         self
@@ -43909,14 +52114,15 @@ impl<'a> CopyImageInfo2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> CopyImageInfo2KHR {
+    pub fn build(self) -> CopyImageInfo2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBlitImageInfo2KHR.html>"]
-pub struct BlitImageInfo2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlitImageInfo2.html>"]
+pub struct BlitImageInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_image: Image,
@@ -43924,13 +52130,14 @@ pub struct BlitImageInfo2KHR {
     pub dst_image: Image,
     pub dst_image_layout: ImageLayout,
     pub region_count: u32,
-    pub p_regions: *const ImageBlit2KHR,
+    pub p_regions: *const ImageBlit2,
     pub filter: Filter,
 }
-impl ::std::default::Default for BlitImageInfo2KHR {
-    fn default() -> BlitImageInfo2KHR {
-        BlitImageInfo2KHR {
-            s_type: StructureType::BLIT_IMAGE_INFO_2_KHR,
+impl ::std::default::Default for BlitImageInfo2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_image: Image::default(),
             src_image_layout: ImageLayout::default(),
@@ -43942,52 +52149,61 @@ impl ::std::default::Default for BlitImageInfo2KHR {
         }
     }
 }
-impl BlitImageInfo2KHR {
-    pub fn builder<'a>() -> BlitImageInfo2KHRBuilder<'a> {
-        BlitImageInfo2KHRBuilder {
-            inner: BlitImageInfo2KHR::default(),
+unsafe impl TaggedStructure for BlitImageInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::BLIT_IMAGE_INFO_2;
+}
+impl BlitImageInfo2 {
+    pub fn builder<'a>() -> BlitImageInfo2Builder<'a> {
+        BlitImageInfo2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct BlitImageInfo2KHRBuilder<'a> {
-    inner: BlitImageInfo2KHR,
+pub struct BlitImageInfo2Builder<'a> {
+    inner: BlitImageInfo2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for BlitImageInfo2KHRBuilder<'a> {
-    type Target = BlitImageInfo2KHR;
+impl<'a> ::std::ops::Deref for BlitImageInfo2Builder<'a> {
+    type Target = BlitImageInfo2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for BlitImageInfo2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for BlitImageInfo2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> BlitImageInfo2KHRBuilder<'a> {
+impl<'a> BlitImageInfo2Builder<'a> {
+    #[inline]
     pub fn src_image(mut self, src_image: Image) -> Self {
         self.inner.src_image = src_image;
         self
     }
+    #[inline]
     pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
         self.inner.src_image_layout = src_image_layout;
         self
     }
+    #[inline]
     pub fn dst_image(mut self, dst_image: Image) -> Self {
         self.inner.dst_image = dst_image;
         self
     }
+    #[inline]
     pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
         self.inner.dst_image_layout = dst_image_layout;
         self
     }
-    pub fn regions(mut self, regions: &'a [ImageBlit2KHR]) -> Self {
+    #[inline]
+    pub fn regions(mut self, regions: &'a [ImageBlit2]) -> Self {
         self.inner.region_count = regions.len() as _;
         self.inner.p_regions = regions.as_ptr();
         self
     }
+    #[inline]
     pub fn filter(mut self, filter: Filter) -> Self {
         self.inner.filter = filter;
         self
@@ -43995,26 +52211,28 @@ impl<'a> BlitImageInfo2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> BlitImageInfo2KHR {
+    pub fn build(self) -> BlitImageInfo2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyBufferToImageInfo2KHR.html>"]
-pub struct CopyBufferToImageInfo2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyBufferToImageInfo2.html>"]
+pub struct CopyBufferToImageInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_buffer: Buffer,
     pub dst_image: Image,
     pub dst_image_layout: ImageLayout,
     pub region_count: u32,
-    pub p_regions: *const BufferImageCopy2KHR,
+    pub p_regions: *const BufferImageCopy2,
 }
-impl ::std::default::Default for CopyBufferToImageInfo2KHR {
-    fn default() -> CopyBufferToImageInfo2KHR {
-        CopyBufferToImageInfo2KHR {
-            s_type: StructureType::COPY_BUFFER_TO_IMAGE_INFO_2_KHR,
+impl ::std::default::Default for CopyBufferToImageInfo2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_buffer: Buffer::default(),
             dst_image: Image::default(),
@@ -44024,44 +52242,51 @@ impl ::std::default::Default for CopyBufferToImageInfo2KHR {
         }
     }
 }
-impl CopyBufferToImageInfo2KHR {
-    pub fn builder<'a>() -> CopyBufferToImageInfo2KHRBuilder<'a> {
-        CopyBufferToImageInfo2KHRBuilder {
-            inner: CopyBufferToImageInfo2KHR::default(),
+unsafe impl TaggedStructure for CopyBufferToImageInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_BUFFER_TO_IMAGE_INFO_2;
+}
+impl CopyBufferToImageInfo2 {
+    pub fn builder<'a>() -> CopyBufferToImageInfo2Builder<'a> {
+        CopyBufferToImageInfo2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct CopyBufferToImageInfo2KHRBuilder<'a> {
-    inner: CopyBufferToImageInfo2KHR,
+pub struct CopyBufferToImageInfo2Builder<'a> {
+    inner: CopyBufferToImageInfo2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2KHRBuilder<'a> {
-    type Target = CopyBufferToImageInfo2KHR;
+impl<'a> ::std::ops::Deref for CopyBufferToImageInfo2Builder<'a> {
+    type Target = CopyBufferToImageInfo2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for CopyBufferToImageInfo2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> CopyBufferToImageInfo2KHRBuilder<'a> {
+impl<'a> CopyBufferToImageInfo2Builder<'a> {
+    #[inline]
     pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
         self.inner.src_buffer = src_buffer;
         self
     }
+    #[inline]
     pub fn dst_image(mut self, dst_image: Image) -> Self {
         self.inner.dst_image = dst_image;
         self
     }
+    #[inline]
     pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
         self.inner.dst_image_layout = dst_image_layout;
         self
     }
-    pub fn regions(mut self, regions: &'a [BufferImageCopy2KHR]) -> Self {
+    #[inline]
+    pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self {
         self.inner.region_count = regions.len() as _;
         self.inner.p_regions = regions.as_ptr();
         self
@@ -44069,26 +52294,28 @@ impl<'a> CopyBufferToImageInfo2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> CopyBufferToImageInfo2KHR {
+    pub fn build(self) -> CopyBufferToImageInfo2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyImageToBufferInfo2KHR.html>"]
-pub struct CopyImageToBufferInfo2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyImageToBufferInfo2.html>"]
+pub struct CopyImageToBufferInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_image: Image,
     pub src_image_layout: ImageLayout,
     pub dst_buffer: Buffer,
     pub region_count: u32,
-    pub p_regions: *const BufferImageCopy2KHR,
+    pub p_regions: *const BufferImageCopy2,
 }
-impl ::std::default::Default for CopyImageToBufferInfo2KHR {
-    fn default() -> CopyImageToBufferInfo2KHR {
-        CopyImageToBufferInfo2KHR {
-            s_type: StructureType::COPY_IMAGE_TO_BUFFER_INFO_2_KHR,
+impl ::std::default::Default for CopyImageToBufferInfo2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_image: Image::default(),
             src_image_layout: ImageLayout::default(),
@@ -44098,44 +52325,51 @@ impl ::std::default::Default for CopyImageToBufferInfo2KHR {
         }
     }
 }
-impl CopyImageToBufferInfo2KHR {
-    pub fn builder<'a>() -> CopyImageToBufferInfo2KHRBuilder<'a> {
-        CopyImageToBufferInfo2KHRBuilder {
-            inner: CopyImageToBufferInfo2KHR::default(),
+unsafe impl TaggedStructure for CopyImageToBufferInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_IMAGE_TO_BUFFER_INFO_2;
+}
+impl CopyImageToBufferInfo2 {
+    pub fn builder<'a>() -> CopyImageToBufferInfo2Builder<'a> {
+        CopyImageToBufferInfo2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct CopyImageToBufferInfo2KHRBuilder<'a> {
-    inner: CopyImageToBufferInfo2KHR,
+pub struct CopyImageToBufferInfo2Builder<'a> {
+    inner: CopyImageToBufferInfo2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2KHRBuilder<'a> {
-    type Target = CopyImageToBufferInfo2KHR;
+impl<'a> ::std::ops::Deref for CopyImageToBufferInfo2Builder<'a> {
+    type Target = CopyImageToBufferInfo2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for CopyImageToBufferInfo2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> CopyImageToBufferInfo2KHRBuilder<'a> {
+impl<'a> CopyImageToBufferInfo2Builder<'a> {
+    #[inline]
     pub fn src_image(mut self, src_image: Image) -> Self {
         self.inner.src_image = src_image;
         self
     }
+    #[inline]
     pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
         self.inner.src_image_layout = src_image_layout;
         self
     }
+    #[inline]
     pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
         self.inner.dst_buffer = dst_buffer;
         self
     }
-    pub fn regions(mut self, regions: &'a [BufferImageCopy2KHR]) -> Self {
+    #[inline]
+    pub fn regions(mut self, regions: &'a [BufferImageCopy2]) -> Self {
         self.inner.region_count = regions.len() as _;
         self.inner.p_regions = regions.as_ptr();
         self
@@ -44143,14 +52377,15 @@ impl<'a> CopyImageToBufferInfo2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> CopyImageToBufferInfo2KHR {
+    pub fn build(self) -> CopyImageToBufferInfo2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResolveImageInfo2KHR.html>"]
-pub struct ResolveImageInfo2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResolveImageInfo2.html>"]
+pub struct ResolveImageInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub src_image: Image,
@@ -44158,12 +52393,13 @@ pub struct ResolveImageInfo2KHR {
     pub dst_image: Image,
     pub dst_image_layout: ImageLayout,
     pub region_count: u32,
-    pub p_regions: *const ImageResolve2KHR,
+    pub p_regions: *const ImageResolve2,
 }
-impl ::std::default::Default for ResolveImageInfo2KHR {
-    fn default() -> ResolveImageInfo2KHR {
-        ResolveImageInfo2KHR {
-            s_type: StructureType::RESOLVE_IMAGE_INFO_2_KHR,
+impl ::std::default::Default for ResolveImageInfo2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             src_image: Image::default(),
             src_image_layout: ImageLayout::default(),
@@ -44174,48 +52410,56 @@ impl ::std::default::Default for ResolveImageInfo2KHR {
         }
     }
 }
-impl ResolveImageInfo2KHR {
-    pub fn builder<'a>() -> ResolveImageInfo2KHRBuilder<'a> {
-        ResolveImageInfo2KHRBuilder {
-            inner: ResolveImageInfo2KHR::default(),
+unsafe impl TaggedStructure for ResolveImageInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::RESOLVE_IMAGE_INFO_2;
+}
+impl ResolveImageInfo2 {
+    pub fn builder<'a>() -> ResolveImageInfo2Builder<'a> {
+        ResolveImageInfo2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct ResolveImageInfo2KHRBuilder<'a> {
-    inner: ResolveImageInfo2KHR,
+pub struct ResolveImageInfo2Builder<'a> {
+    inner: ResolveImageInfo2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for ResolveImageInfo2KHRBuilder<'a> {
-    type Target = ResolveImageInfo2KHR;
+impl<'a> ::std::ops::Deref for ResolveImageInfo2Builder<'a> {
+    type Target = ResolveImageInfo2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for ResolveImageInfo2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for ResolveImageInfo2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> ResolveImageInfo2KHRBuilder<'a> {
+impl<'a> ResolveImageInfo2Builder<'a> {
+    #[inline]
     pub fn src_image(mut self, src_image: Image) -> Self {
         self.inner.src_image = src_image;
         self
     }
+    #[inline]
     pub fn src_image_layout(mut self, src_image_layout: ImageLayout) -> Self {
         self.inner.src_image_layout = src_image_layout;
         self
     }
+    #[inline]
     pub fn dst_image(mut self, dst_image: Image) -> Self {
         self.inner.dst_image = dst_image;
         self
     }
+    #[inline]
     pub fn dst_image_layout(mut self, dst_image_layout: ImageLayout) -> Self {
         self.inner.dst_image_layout = dst_image_layout;
         self
     }
-    pub fn regions(mut self, regions: &'a [ImageResolve2KHR]) -> Self {
+    #[inline]
+    pub fn regions(mut self, regions: &'a [ImageResolve2]) -> Self {
         self.inner.region_count = regions.len() as _;
         self.inner.p_regions = regions.as_ptr();
         self
@@ -44223,13 +52467,14 @@ impl<'a> ResolveImageInfo2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> ResolveImageInfo2KHR {
+    pub fn build(self) -> ResolveImageInfo2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html>"]
 pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -44237,19 +52482,24 @@ pub struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
     pub sparse_image_int64_atomics: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
-    fn default() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
-        PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_image_int64_atomics: Bool32::default(),
             sparse_image_int64_atomics: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT;
+}
 impl PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
         PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder {
-            inner: PhysicalDeviceShaderImageAtomicInt64FeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -44278,10 +52528,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderImageAtomicInt64FeaturesEX
     }
 }
 impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn shader_image_int64_atomics(mut self, shader_image_int64_atomics: bool) -> Self {
         self.inner.shader_image_int64_atomics = shader_image_int64_atomics.into();
         self
     }
+    #[inline]
     pub fn sparse_image_int64_atomics(mut self, sparse_image_int64_atomics: bool) -> Self {
         self.inner.sparse_image_int64_atomics = sparse_image_int64_atomics.into();
         self
@@ -44294,8 +52546,9 @@ impl<'a> PhysicalDeviceShaderImageAtomicInt64FeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFragmentShadingRateAttachmentInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFragmentShadingRateAttachmentInfoKHR.html>"]
 pub struct FragmentShadingRateAttachmentInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -44303,19 +52556,23 @@ pub struct FragmentShadingRateAttachmentInfoKHR {
     pub shading_rate_attachment_texel_size: Extent2D,
 }
 impl ::std::default::Default for FragmentShadingRateAttachmentInfoKHR {
-    fn default() -> FragmentShadingRateAttachmentInfoKHR {
-        FragmentShadingRateAttachmentInfoKHR {
-            s_type: StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_fragment_shading_rate_attachment: ::std::ptr::null(),
             shading_rate_attachment_texel_size: Extent2D::default(),
         }
     }
 }
+unsafe impl TaggedStructure for FragmentShadingRateAttachmentInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
+}
 impl FragmentShadingRateAttachmentInfoKHR {
     pub fn builder<'a>() -> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
         FragmentShadingRateAttachmentInfoKHRBuilder {
-            inner: FragmentShadingRateAttachmentInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -44339,6 +52596,7 @@ impl<'a> ::std::ops::DerefMut for FragmentShadingRateAttachmentInfoKHRBuilder<'a
     }
 }
 impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
+    #[inline]
     pub fn fragment_shading_rate_attachment(
         mut self,
         fragment_shading_rate_attachment: &'a AttachmentReference2,
@@ -44346,6 +52604,7 @@ impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
         self.inner.p_fragment_shading_rate_attachment = fragment_shading_rate_attachment;
         self
     }
+    #[inline]
     pub fn shading_rate_attachment_texel_size(
         mut self,
         shading_rate_attachment_texel_size: Extent2D,
@@ -44361,8 +52620,9 @@ impl<'a> FragmentShadingRateAttachmentInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html>"]
 pub struct PipelineFragmentShadingRateStateCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -44370,19 +52630,24 @@ pub struct PipelineFragmentShadingRateStateCreateInfoKHR {
     pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
 }
 impl ::std::default::Default for PipelineFragmentShadingRateStateCreateInfoKHR {
-    fn default() -> PipelineFragmentShadingRateStateCreateInfoKHR {
-        PipelineFragmentShadingRateStateCreateInfoKHR {
-            s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             fragment_size: Extent2D::default(),
             combiner_ops: unsafe { ::std::mem::zeroed() },
         }
     }
 }
+unsafe impl TaggedStructure for PipelineFragmentShadingRateStateCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR;
+}
 impl PipelineFragmentShadingRateStateCreateInfoKHR {
     pub fn builder<'a>() -> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
         PipelineFragmentShadingRateStateCreateInfoKHRBuilder {
-            inner: PipelineFragmentShadingRateStateCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -44409,10 +52674,12 @@ impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateStateCreateInfoKHRB
     }
 }
 impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self {
         self.inner.fragment_size = fragment_size;
         self
     }
+    #[inline]
     pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self {
         self.inner.combiner_ops = combiner_ops;
         self
@@ -44425,8 +52692,9 @@ impl<'a> PipelineFragmentShadingRateStateCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html>"]
 pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -44435,9 +52703,10 @@ pub struct PhysicalDeviceFragmentShadingRateFeaturesKHR {
     pub attachment_fragment_shading_rate: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR {
-    fn default() -> PhysicalDeviceFragmentShadingRateFeaturesKHR {
-        PhysicalDeviceFragmentShadingRateFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             pipeline_fragment_shading_rate: Bool32::default(),
             primitive_fragment_shading_rate: Bool32::default(),
@@ -44445,10 +52714,14 @@ impl ::std::default::Default for PhysicalDeviceFragmentShadingRateFeaturesKHR {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR;
+}
 impl PhysicalDeviceFragmentShadingRateFeaturesKHR {
     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
         PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder {
-            inner: PhysicalDeviceFragmentShadingRateFeaturesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -44477,10 +52750,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateFeaturesKHRBu
     }
 }
 impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
+    #[inline]
     pub fn pipeline_fragment_shading_rate(mut self, pipeline_fragment_shading_rate: bool) -> Self {
         self.inner.pipeline_fragment_shading_rate = pipeline_fragment_shading_rate.into();
         self
     }
+    #[inline]
     pub fn primitive_fragment_shading_rate(
         mut self,
         primitive_fragment_shading_rate: bool,
@@ -44488,6 +52763,7 @@ impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
         self.inner.primitive_fragment_shading_rate = primitive_fragment_shading_rate.into();
         self
     }
+    #[inline]
     pub fn attachment_fragment_shading_rate(
         mut self,
         attachment_fragment_shading_rate: bool,
@@ -44503,8 +52779,9 @@ impl<'a> PhysicalDeviceFragmentShadingRateFeaturesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html>"]
 pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -44527,9 +52804,10 @@ pub struct PhysicalDeviceFragmentShadingRatePropertiesKHR {
     pub fragment_shading_rate_strict_multiply_combiner: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR {
-    fn default() -> PhysicalDeviceFragmentShadingRatePropertiesKHR {
-        PhysicalDeviceFragmentShadingRatePropertiesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             min_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
             max_fragment_shading_rate_attachment_texel_size: Extent2D::default(),
@@ -44551,10 +52829,14 @@ impl ::std::default::Default for PhysicalDeviceFragmentShadingRatePropertiesKHR
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRatePropertiesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
+}
 impl PhysicalDeviceFragmentShadingRatePropertiesKHR {
     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
         PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder {
-            inner: PhysicalDeviceFragmentShadingRatePropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -44581,6 +52863,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRatePropertiesKHR
     }
 }
 impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn min_fragment_shading_rate_attachment_texel_size(
         mut self,
         min_fragment_shading_rate_attachment_texel_size: Extent2D,
@@ -44589,6 +52872,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             min_fragment_shading_rate_attachment_texel_size;
         self
     }
+    #[inline]
     pub fn max_fragment_shading_rate_attachment_texel_size(
         mut self,
         max_fragment_shading_rate_attachment_texel_size: Extent2D,
@@ -44597,6 +52881,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             max_fragment_shading_rate_attachment_texel_size;
         self
     }
+    #[inline]
     pub fn max_fragment_shading_rate_attachment_texel_size_aspect_ratio(
         mut self,
         max_fragment_shading_rate_attachment_texel_size_aspect_ratio: u32,
@@ -44606,6 +52891,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             max_fragment_shading_rate_attachment_texel_size_aspect_ratio;
         self
     }
+    #[inline]
     pub fn primitive_fragment_shading_rate_with_multiple_viewports(
         mut self,
         primitive_fragment_shading_rate_with_multiple_viewports: bool,
@@ -44615,6 +52901,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             primitive_fragment_shading_rate_with_multiple_viewports.into();
         self
     }
+    #[inline]
     pub fn layered_shading_rate_attachments(
         mut self,
         layered_shading_rate_attachments: bool,
@@ -44622,6 +52909,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
         self.inner.layered_shading_rate_attachments = layered_shading_rate_attachments.into();
         self
     }
+    #[inline]
     pub fn fragment_shading_rate_non_trivial_combiner_ops(
         mut self,
         fragment_shading_rate_non_trivial_combiner_ops: bool,
@@ -44630,14 +52918,17 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             fragment_shading_rate_non_trivial_combiner_ops.into();
         self
     }
+    #[inline]
     pub fn max_fragment_size(mut self, max_fragment_size: Extent2D) -> Self {
         self.inner.max_fragment_size = max_fragment_size;
         self
     }
+    #[inline]
     pub fn max_fragment_size_aspect_ratio(mut self, max_fragment_size_aspect_ratio: u32) -> Self {
         self.inner.max_fragment_size_aspect_ratio = max_fragment_size_aspect_ratio;
         self
     }
+    #[inline]
     pub fn max_fragment_shading_rate_coverage_samples(
         mut self,
         max_fragment_shading_rate_coverage_samples: u32,
@@ -44646,6 +52937,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             max_fragment_shading_rate_coverage_samples;
         self
     }
+    #[inline]
     pub fn max_fragment_shading_rate_rasterization_samples(
         mut self,
         max_fragment_shading_rate_rasterization_samples: SampleCountFlags,
@@ -44654,6 +52946,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             max_fragment_shading_rate_rasterization_samples;
         self
     }
+    #[inline]
     pub fn fragment_shading_rate_with_shader_depth_stencil_writes(
         mut self,
         fragment_shading_rate_with_shader_depth_stencil_writes: bool,
@@ -44663,6 +52956,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             fragment_shading_rate_with_shader_depth_stencil_writes.into();
         self
     }
+    #[inline]
     pub fn fragment_shading_rate_with_sample_mask(
         mut self,
         fragment_shading_rate_with_sample_mask: bool,
@@ -44671,6 +52965,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             fragment_shading_rate_with_sample_mask.into();
         self
     }
+    #[inline]
     pub fn fragment_shading_rate_with_shader_sample_mask(
         mut self,
         fragment_shading_rate_with_shader_sample_mask: bool,
@@ -44679,6 +52974,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             fragment_shading_rate_with_shader_sample_mask.into();
         self
     }
+    #[inline]
     pub fn fragment_shading_rate_with_conservative_rasterization(
         mut self,
         fragment_shading_rate_with_conservative_rasterization: bool,
@@ -44688,6 +52984,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             fragment_shading_rate_with_conservative_rasterization.into();
         self
     }
+    #[inline]
     pub fn fragment_shading_rate_with_fragment_shader_interlock(
         mut self,
         fragment_shading_rate_with_fragment_shader_interlock: bool,
@@ -44697,6 +52994,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             fragment_shading_rate_with_fragment_shader_interlock.into();
         self
     }
+    #[inline]
     pub fn fragment_shading_rate_with_custom_sample_locations(
         mut self,
         fragment_shading_rate_with_custom_sample_locations: bool,
@@ -44706,6 +53004,7 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
             fragment_shading_rate_with_custom_sample_locations.into();
         self
     }
+    #[inline]
     pub fn fragment_shading_rate_strict_multiply_combiner(
         mut self,
         fragment_shading_rate_strict_multiply_combiner: bool,
@@ -44722,8 +53021,9 @@ impl<'a> PhysicalDeviceFragmentShadingRatePropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html>"]
 pub struct PhysicalDeviceFragmentShadingRateKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -44731,19 +53031,23 @@ pub struct PhysicalDeviceFragmentShadingRateKHR {
     pub fragment_size: Extent2D,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateKHR {
-    fn default() -> PhysicalDeviceFragmentShadingRateKHR {
-        PhysicalDeviceFragmentShadingRateKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             sample_counts: SampleCountFlags::default(),
             fragment_size: Extent2D::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR;
+}
 impl PhysicalDeviceFragmentShadingRateKHR {
     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
         PhysicalDeviceFragmentShadingRateKHRBuilder {
-            inner: PhysicalDeviceFragmentShadingRateKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -44765,10 +53069,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateKHRBuilder<'a
     }
 }
 impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
+    #[inline]
     pub fn sample_counts(mut self, sample_counts: SampleCountFlags) -> Self {
         self.inner.sample_counts = sample_counts;
         self
     }
+    #[inline]
     pub fn fragment_size(mut self, fragment_size: Extent2D) -> Self {
         self.inner.fragment_size = fragment_size;
         self
@@ -44781,57 +53087,61 @@ impl<'a> PhysicalDeviceFragmentShadingRateKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR.html>"]
-pub struct PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTerminateInvocationFeatures.html>"]
+pub struct PhysicalDeviceShaderTerminateInvocationFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shader_terminate_invocation: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
-    fn default() -> PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
-        PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR,
+impl ::std::default::Default for PhysicalDeviceShaderTerminateInvocationFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_terminate_invocation: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
-    pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
-        PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder {
-            inner: PhysicalDeviceShaderTerminateInvocationFeaturesKHR::default(),
+unsafe impl TaggedStructure for PhysicalDeviceShaderTerminateInvocationFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
+}
+impl PhysicalDeviceShaderTerminateInvocationFeatures {
+    pub fn builder<'a>() -> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
+        PhysicalDeviceShaderTerminateInvocationFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
-    inner: PhysicalDeviceShaderTerminateInvocationFeaturesKHR,
+pub struct PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
+    inner: PhysicalDeviceShaderTerminateInvocationFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'_>
-{
-}
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeaturesKHR {}
-unsafe impl ExtendsDeviceCreateInfo
-    for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'_>
+    for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_>
 {
 }
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesKHR {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
-    type Target = PhysicalDeviceShaderTerminateInvocationFeaturesKHR;
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTerminateInvocationFeatures {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTerminateInvocationFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
+    type Target = PhysicalDeviceShaderTerminateInvocationFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
+impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesBuilder<'a> {
+    #[inline]
     pub fn shader_terminate_invocation(mut self, shader_terminate_invocation: bool) -> Self {
         self.inner.shader_terminate_invocation = shader_terminate_invocation.into();
         self
@@ -44839,13 +53149,14 @@ impl<'a> PhysicalDeviceShaderTerminateInvocationFeaturesKHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
+    pub fn build(self) -> PhysicalDeviceShaderTerminateInvocationFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html>"]
 pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -44854,9 +53165,10 @@ pub struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
     pub no_invocation_fragment_shading_rates: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
-    fn default() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
-        PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             fragment_shading_rate_enums: Bool32::default(),
             supersample_fragment_shading_rates: Bool32::default(),
@@ -44864,10 +53176,14 @@ impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsFeaturesN
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV;
+}
 impl PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
         PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder {
-            inner: PhysicalDeviceFragmentShadingRateEnumsFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -44899,10 +53215,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsFeatures
     }
 }
 impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn fragment_shading_rate_enums(mut self, fragment_shading_rate_enums: bool) -> Self {
         self.inner.fragment_shading_rate_enums = fragment_shading_rate_enums.into();
         self
     }
+    #[inline]
     pub fn supersample_fragment_shading_rates(
         mut self,
         supersample_fragment_shading_rates: bool,
@@ -44910,6 +53228,7 @@ impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
         self.inner.supersample_fragment_shading_rates = supersample_fragment_shading_rates.into();
         self
     }
+    #[inline]
     pub fn no_invocation_fragment_shading_rates(
         mut self,
         no_invocation_fragment_shading_rates: bool,
@@ -44926,26 +53245,32 @@ impl<'a> PhysicalDeviceFragmentShadingRateEnumsFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html>"]
 pub struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub max_fragment_shading_rate_invocation_count: SampleCountFlags,
 }
 impl ::std::default::Default for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
-    fn default() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
-        PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             max_fragment_shading_rate_invocation_count: SampleCountFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV;
+}
 impl PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
     pub fn builder<'a>() -> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
         PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder {
-            inner: PhysicalDeviceFragmentShadingRateEnumsPropertiesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -44975,6 +53300,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShadingRateEnumsProperti
     }
 }
 impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
+    #[inline]
     pub fn max_fragment_shading_rate_invocation_count(
         mut self,
         max_fragment_shading_rate_invocation_count: SampleCountFlags,
@@ -44991,8 +53317,9 @@ impl<'a> PhysicalDeviceFragmentShadingRateEnumsPropertiesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html>"]
 pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -45001,9 +53328,10 @@ pub struct PipelineFragmentShadingRateEnumStateCreateInfoNV {
     pub combiner_ops: [FragmentShadingRateCombinerOpKHR; 2],
 }
 impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoNV {
-    fn default() -> PipelineFragmentShadingRateEnumStateCreateInfoNV {
-        PipelineFragmentShadingRateEnumStateCreateInfoNV {
-            s_type: StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             shading_rate_type: FragmentShadingRateTypeNV::default(),
             shading_rate: FragmentShadingRateNV::default(),
@@ -45011,10 +53339,14 @@ impl ::std::default::Default for PipelineFragmentShadingRateEnumStateCreateInfoN
         }
     }
 }
+unsafe impl TaggedStructure for PipelineFragmentShadingRateEnumStateCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV;
+}
 impl PipelineFragmentShadingRateEnumStateCreateInfoNV {
     pub fn builder<'a>() -> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
         PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder {
-            inner: PipelineFragmentShadingRateEnumStateCreateInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -45041,14 +53373,17 @@ impl<'a> ::std::ops::DerefMut for PipelineFragmentShadingRateEnumStateCreateInfo
     }
 }
 impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
+    #[inline]
     pub fn shading_rate_type(mut self, shading_rate_type: FragmentShadingRateTypeNV) -> Self {
         self.inner.shading_rate_type = shading_rate_type;
         self
     }
+    #[inline]
     pub fn shading_rate(mut self, shading_rate: FragmentShadingRateNV) -> Self {
         self.inner.shading_rate = shading_rate;
         self
     }
+    #[inline]
     pub fn combiner_ops(mut self, combiner_ops: [FragmentShadingRateCombinerOpKHR; 2]) -> Self {
         self.inner.combiner_ops = combiner_ops;
         self
@@ -45061,8 +53396,9 @@ impl<'a> PipelineFragmentShadingRateEnumStateCreateInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureBuildSizesInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildSizesInfoKHR.html>"]
 pub struct AccelerationStructureBuildSizesInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -45071,9 +53407,10 @@ pub struct AccelerationStructureBuildSizesInfoKHR {
     pub build_scratch_size: DeviceSize,
 }
 impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR {
-    fn default() -> AccelerationStructureBuildSizesInfoKHR {
-        AccelerationStructureBuildSizesInfoKHR {
-            s_type: StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             acceleration_structure_size: DeviceSize::default(),
             update_scratch_size: DeviceSize::default(),
@@ -45081,10 +53418,14 @@ impl ::std::default::Default for AccelerationStructureBuildSizesInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureBuildSizesInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR;
+}
 impl AccelerationStructureBuildSizesInfoKHR {
     pub fn builder<'a>() -> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
         AccelerationStructureBuildSizesInfoKHRBuilder {
-            inner: AccelerationStructureBuildSizesInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -45106,14 +53447,17 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureBuildSizesInfoKHRBuilder<
     }
 }
 impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
+    #[inline]
     pub fn acceleration_structure_size(mut self, acceleration_structure_size: DeviceSize) -> Self {
         self.inner.acceleration_structure_size = acceleration_structure_size;
         self
     }
+    #[inline]
     pub fn update_scratch_size(mut self, update_scratch_size: DeviceSize) -> Self {
         self.inner.update_scratch_size = update_scratch_size;
         self
     }
+    #[inline]
     pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self {
         self.inner.build_scratch_size = build_scratch_size;
         self
@@ -45126,57 +53470,283 @@ impl<'a> AccelerationStructureBuildSizesInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE.html>"]
-pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.html>"]
+pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
-    pub mutable_descriptor_type: Bool32,
+    pub image2_d_view_of3_d: Bool32,
+    pub sampler2_d_view_of3_d: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceImage2DViewOf3DFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            image2_d_view_of3_d: Bool32::default(),
+            sampler2_d_view_of3_d: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceImage2DViewOf3DFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT;
 }
-impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
-    fn default() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
-        PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
-            s_type: StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE,
+impl PhysicalDeviceImage2DViewOf3DFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
+        PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceImage2DViewOf3DFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImage2DViewOf3DFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImage2DViewOf3DFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceImage2DViewOf3DFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceImage2DViewOf3DFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn image2_d_view_of3_d(mut self, image2_d_view_of3_d: bool) -> Self {
+        self.inner.image2_d_view_of3_d = image2_d_view_of3_d.into();
+        self
+    }
+    #[inline]
+    pub fn sampler2_d_view_of3_d(mut self, sampler2_d_view_of3_d: bool) -> Self {
+        self.inner.sampler2_d_view_of3_d = sampler2_d_view_of3_d.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceImage2DViewOf3DFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.html>"]
+pub struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub image_sliced_view_of3_d: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
-            mutable_descriptor_type: Bool32::default(),
+            image_sliced_view_of3_d: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
-    pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
-        PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder {
-            inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE::default(),
+unsafe impl TaggedStructure for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT;
+}
+impl PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
+        PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
-    inner: PhysicalDeviceMutableDescriptorTypeFeaturesVALVE,
+pub struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceImageSlicedViewOf3DFeaturesEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_>
+    for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceImageSlicedViewOf3DFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceImageSlicedViewOf3DFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn image_sliced_view_of3_d(mut self, image_sliced_view_of3_d: bool) -> Self {
+        self.inner.image_sliced_view_of3_d = image_sliced_view_of3_d.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.html>"]
+pub struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub attachment_feedback_loop_dynamic_state: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            attachment_feedback_loop_dynamic_state: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT;
+}
+impl PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
+        PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'_>
 {
 }
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {}
 unsafe impl ExtendsDeviceCreateInfo
-    for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'_>
+    for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT
+{
+}
+impl<'a> ::std::ops::Deref
+    for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a>
+{
+    type Target = PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut
+    for PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a>
 {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
 }
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
-    type Target = PhysicalDeviceMutableDescriptorTypeFeaturesVALVE;
+impl<'a> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn attachment_feedback_loop_dynamic_state(
+        mut self,
+        attachment_feedback_loop_dynamic_state: bool,
+    ) -> Self {
+        self.inner.attachment_feedback_loop_dynamic_state =
+            attachment_feedback_loop_dynamic_state.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.html>"]
+pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub mutable_descriptor_type: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            mutable_descriptor_type: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
+}
+impl PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
+        PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceMutableDescriptorTypeFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMutableDescriptorTypeFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceMutableDescriptorTypeFeaturesEXT;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
+impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn mutable_descriptor_type(mut self, mutable_descriptor_type: bool) -> Self {
         self.inner.mutable_descriptor_type = mutable_descriptor_type.into();
         self
@@ -45184,50 +53754,53 @@ impl<'a> PhysicalDeviceMutableDescriptorTypeFeaturesVALVEBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+    pub fn build(self) -> PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMutableDescriptorTypeListVALVE.html>"]
-pub struct MutableDescriptorTypeListVALVE {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeListEXT.html>"]
+pub struct MutableDescriptorTypeListEXT {
     pub descriptor_type_count: u32,
     pub p_descriptor_types: *const DescriptorType,
 }
-impl ::std::default::Default for MutableDescriptorTypeListVALVE {
-    fn default() -> MutableDescriptorTypeListVALVE {
-        MutableDescriptorTypeListVALVE {
+impl ::std::default::Default for MutableDescriptorTypeListEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
             descriptor_type_count: u32::default(),
             p_descriptor_types: ::std::ptr::null(),
         }
     }
 }
-impl MutableDescriptorTypeListVALVE {
-    pub fn builder<'a>() -> MutableDescriptorTypeListVALVEBuilder<'a> {
-        MutableDescriptorTypeListVALVEBuilder {
-            inner: MutableDescriptorTypeListVALVE::default(),
+impl MutableDescriptorTypeListEXT {
+    pub fn builder<'a>() -> MutableDescriptorTypeListEXTBuilder<'a> {
+        MutableDescriptorTypeListEXTBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct MutableDescriptorTypeListVALVEBuilder<'a> {
-    inner: MutableDescriptorTypeListVALVE,
+pub struct MutableDescriptorTypeListEXTBuilder<'a> {
+    inner: MutableDescriptorTypeListEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for MutableDescriptorTypeListVALVEBuilder<'a> {
-    type Target = MutableDescriptorTypeListVALVE;
+impl<'a> ::std::ops::Deref for MutableDescriptorTypeListEXTBuilder<'a> {
+    type Target = MutableDescriptorTypeListEXT;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListVALVEBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeListEXTBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> MutableDescriptorTypeListVALVEBuilder<'a> {
+impl<'a> MutableDescriptorTypeListEXTBuilder<'a> {
+    #[inline]
     pub fn descriptor_types(mut self, descriptor_types: &'a [DescriptorType]) -> Self {
         self.inner.descriptor_type_count = descriptor_types.len() as _;
         self.inner.p_descriptor_types = descriptor_types.as_ptr();
@@ -45236,64 +53809,67 @@ impl<'a> MutableDescriptorTypeListVALVEBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> MutableDescriptorTypeListVALVE {
+    pub fn build(self) -> MutableDescriptorTypeListEXT {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMutableDescriptorTypeCreateInfoVALVE.html>"]
-pub struct MutableDescriptorTypeCreateInfoVALVE {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMutableDescriptorTypeCreateInfoEXT.html>"]
+pub struct MutableDescriptorTypeCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub mutable_descriptor_type_list_count: u32,
-    pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListVALVE,
+    pub p_mutable_descriptor_type_lists: *const MutableDescriptorTypeListEXT,
 }
-impl ::std::default::Default for MutableDescriptorTypeCreateInfoVALVE {
-    fn default() -> MutableDescriptorTypeCreateInfoVALVE {
-        MutableDescriptorTypeCreateInfoVALVE {
-            s_type: StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE,
+impl ::std::default::Default for MutableDescriptorTypeCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             mutable_descriptor_type_list_count: u32::default(),
             p_mutable_descriptor_type_lists: ::std::ptr::null(),
         }
     }
 }
-impl MutableDescriptorTypeCreateInfoVALVE {
-    pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
-        MutableDescriptorTypeCreateInfoVALVEBuilder {
-            inner: MutableDescriptorTypeCreateInfoVALVE::default(),
+unsafe impl TaggedStructure for MutableDescriptorTypeCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
+}
+impl MutableDescriptorTypeCreateInfoEXT {
+    pub fn builder<'a>() -> MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
+        MutableDescriptorTypeCreateInfoEXTBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
-    inner: MutableDescriptorTypeCreateInfoVALVE,
+pub struct MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
+    inner: MutableDescriptorTypeCreateInfoEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsDescriptorSetLayoutCreateInfo
-    for MutableDescriptorTypeCreateInfoVALVEBuilder<'_>
-{
-}
-unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
-unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVEBuilder<'_> {}
-unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoVALVE {}
-impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
-    type Target = MutableDescriptorTypeCreateInfoVALVE;
+unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsDescriptorSetLayoutCreateInfo for MutableDescriptorTypeCreateInfoEXT {}
+unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsDescriptorPoolCreateInfo for MutableDescriptorTypeCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
+    type Target = MutableDescriptorTypeCreateInfoEXT;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
+impl<'a> MutableDescriptorTypeCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn mutable_descriptor_type_lists(
         mut self,
-        mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListVALVE],
+        mutable_descriptor_type_lists: &'a [MutableDescriptorTypeListEXT],
     ) -> Self {
         self.inner.mutable_descriptor_type_list_count = mutable_descriptor_type_lists.len() as _;
         self.inner.p_mutable_descriptor_type_lists = mutable_descriptor_type_lists.as_ptr();
@@ -45302,31 +53878,172 @@ impl<'a> MutableDescriptorTypeCreateInfoVALVEBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> MutableDescriptorTypeCreateInfoVALVE {
+    pub fn build(self) -> MutableDescriptorTypeCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClipControlFeaturesEXT.html>"]
+pub struct PhysicalDeviceDepthClipControlFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub depth_clip_control: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceDepthClipControlFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            depth_clip_control: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDepthClipControlFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT;
+}
+impl PhysicalDeviceDepthClipControlFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
+        PhysicalDeviceDepthClipControlFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceDepthClipControlFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClipControlFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClipControlFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceDepthClipControlFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDepthClipControlFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn depth_clip_control(mut self, depth_clip_control: bool) -> Self {
+        self.inner.depth_clip_control = depth_clip_control.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDepthClipControlFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineViewportDepthClipControlCreateInfoEXT.html>"]
+pub struct PipelineViewportDepthClipControlCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub negative_one_to_one: Bool32,
+}
+impl ::std::default::Default for PipelineViewportDepthClipControlCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            negative_one_to_one: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PipelineViewportDepthClipControlCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT;
+}
+impl PipelineViewportDepthClipControlCreateInfoEXT {
+    pub fn builder<'a>() -> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
+        PipelineViewportDepthClipControlCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
+    inner: PipelineViewportDepthClipControlCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPipelineViewportStateCreateInfo
+    for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPipelineViewportStateCreateInfo
+    for PipelineViewportDepthClipControlCreateInfoEXT
+{
+}
+impl<'a> ::std::ops::Deref for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
+    type Target = PipelineViewportDepthClipControlCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PipelineViewportDepthClipControlCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn negative_one_to_one(mut self, negative_one_to_one: bool) -> Self {
+        self.inner.negative_one_to_one = negative_one_to_one.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PipelineViewportDepthClipControlCreateInfoEXT {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html>"]
 pub struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub vertex_input_dynamic_state: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
-    fn default() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
-        PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             vertex_input_dynamic_state: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
+}
 impl PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
         PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder {
-            inner: PhysicalDeviceVertexInputDynamicStateFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -45358,6 +54075,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVertexInputDynamicStateFeaturesE
     }
 }
 impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn vertex_input_dynamic_state(mut self, vertex_input_dynamic_state: bool) -> Self {
         self.inner.vertex_input_dynamic_state = vertex_input_dynamic_state.into();
         self
@@ -45370,26 +54088,32 @@ impl<'a> PhysicalDeviceVertexInputDynamicStateFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html>"]
 pub struct PhysicalDeviceExternalMemoryRDMAFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub external_memory_rdma: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceExternalMemoryRDMAFeaturesNV {
-    fn default() -> PhysicalDeviceExternalMemoryRDMAFeaturesNV {
-        PhysicalDeviceExternalMemoryRDMAFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             external_memory_rdma: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceExternalMemoryRDMAFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV;
+}
 impl PhysicalDeviceExternalMemoryRDMAFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
         PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder {
-            inner: PhysicalDeviceExternalMemoryRDMAFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -45418,6 +54142,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceExternalMemoryRDMAFeaturesNVBuil
     }
 }
 impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn external_memory_rdma(mut self, external_memory_rdma: bool) -> Self {
         self.inner.external_memory_rdma = external_memory_rdma.into();
         self
@@ -45430,8 +54155,9 @@ impl<'a> PhysicalDeviceExternalMemoryRDMAFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputBindingDescription2EXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputBindingDescription2EXT.html>"]
 pub struct VertexInputBindingDescription2EXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -45441,9 +54167,10 @@ pub struct VertexInputBindingDescription2EXT {
     pub divisor: u32,
 }
 impl ::std::default::Default for VertexInputBindingDescription2EXT {
-    fn default() -> VertexInputBindingDescription2EXT {
-        VertexInputBindingDescription2EXT {
-            s_type: StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             binding: u32::default(),
             stride: u32::default(),
@@ -45452,10 +54179,13 @@ impl ::std::default::Default for VertexInputBindingDescription2EXT {
         }
     }
 }
+unsafe impl TaggedStructure for VertexInputBindingDescription2EXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT;
+}
 impl VertexInputBindingDescription2EXT {
     pub fn builder<'a>() -> VertexInputBindingDescription2EXTBuilder<'a> {
         VertexInputBindingDescription2EXTBuilder {
-            inner: VertexInputBindingDescription2EXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -45477,18 +54207,22 @@ impl<'a> ::std::ops::DerefMut for VertexInputBindingDescription2EXTBuilder<'a> {
     }
 }
 impl<'a> VertexInputBindingDescription2EXTBuilder<'a> {
+    #[inline]
     pub fn binding(mut self, binding: u32) -> Self {
         self.inner.binding = binding;
         self
     }
+    #[inline]
     pub fn stride(mut self, stride: u32) -> Self {
         self.inner.stride = stride;
         self
     }
+    #[inline]
     pub fn input_rate(mut self, input_rate: VertexInputRate) -> Self {
         self.inner.input_rate = input_rate;
         self
     }
+    #[inline]
     pub fn divisor(mut self, divisor: u32) -> Self {
         self.inner.divisor = divisor;
         self
@@ -45501,8 +54235,9 @@ impl<'a> VertexInputBindingDescription2EXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputAttributeDescription2EXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputAttributeDescription2EXT.html>"]
 pub struct VertexInputAttributeDescription2EXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -45512,9 +54247,10 @@ pub struct VertexInputAttributeDescription2EXT {
     pub offset: u32,
 }
 impl ::std::default::Default for VertexInputAttributeDescription2EXT {
-    fn default() -> VertexInputAttributeDescription2EXT {
-        VertexInputAttributeDescription2EXT {
-            s_type: StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             location: u32::default(),
             binding: u32::default(),
@@ -45523,10 +54259,13 @@ impl ::std::default::Default for VertexInputAttributeDescription2EXT {
         }
     }
 }
+unsafe impl TaggedStructure for VertexInputAttributeDescription2EXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT;
+}
 impl VertexInputAttributeDescription2EXT {
     pub fn builder<'a>() -> VertexInputAttributeDescription2EXTBuilder<'a> {
         VertexInputAttributeDescription2EXTBuilder {
-            inner: VertexInputAttributeDescription2EXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -45548,18 +54287,22 @@ impl<'a> ::std::ops::DerefMut for VertexInputAttributeDescription2EXTBuilder<'a>
     }
 }
 impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> {
+    #[inline]
     pub fn location(mut self, location: u32) -> Self {
         self.inner.location = location;
         self
     }
+    #[inline]
     pub fn binding(mut self, binding: u32) -> Self {
         self.inner.binding = binding;
         self
     }
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: u32) -> Self {
         self.inner.offset = offset;
         self
@@ -45572,26 +54315,32 @@ impl<'a> VertexInputAttributeDescription2EXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html>"]
 pub struct PhysicalDeviceColorWriteEnableFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub color_write_enable: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceColorWriteEnableFeaturesEXT {
-    fn default() -> PhysicalDeviceColorWriteEnableFeaturesEXT {
-        PhysicalDeviceColorWriteEnableFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             color_write_enable: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceColorWriteEnableFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT;
+}
 impl PhysicalDeviceColorWriteEnableFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
         PhysicalDeviceColorWriteEnableFeaturesEXTBuilder {
-            inner: PhysicalDeviceColorWriteEnableFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -45620,6 +54369,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceColorWriteEnableFeaturesEXTBuild
     }
 }
 impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn color_write_enable(mut self, color_write_enable: bool) -> Self {
         self.inner.color_write_enable = color_write_enable.into();
         self
@@ -45632,8 +54382,9 @@ impl<'a> PhysicalDeviceColorWriteEnableFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineColorWriteCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineColorWriteCreateInfoEXT.html>"]
 pub struct PipelineColorWriteCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -45641,19 +54392,23 @@ pub struct PipelineColorWriteCreateInfoEXT {
     pub p_color_write_enables: *const Bool32,
 }
 impl ::std::default::Default for PipelineColorWriteCreateInfoEXT {
-    fn default() -> PipelineColorWriteCreateInfoEXT {
-        PipelineColorWriteCreateInfoEXT {
-            s_type: StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             attachment_count: u32::default(),
             p_color_write_enables: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineColorWriteCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_COLOR_WRITE_CREATE_INFO_EXT;
+}
 impl PipelineColorWriteCreateInfoEXT {
     pub fn builder<'a>() -> PipelineColorWriteCreateInfoEXTBuilder<'a> {
         PipelineColorWriteCreateInfoEXTBuilder {
-            inner: PipelineColorWriteCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -45680,6 +54435,7 @@ impl<'a> ::std::ops::DerefMut for PipelineColorWriteCreateInfoEXTBuilder<'a> {
     }
 }
 impl<'a> PipelineColorWriteCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn color_write_enables(mut self, color_write_enables: &'a [Bool32]) -> Self {
         self.inner.attachment_count = color_write_enables.len() as _;
         self.inner.p_color_write_enables = color_write_enables.as_ptr();
@@ -45693,88 +54449,98 @@ impl<'a> PipelineColorWriteCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryBarrier2KHR.html>"]
-pub struct MemoryBarrier2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryBarrier2.html>"]
+pub struct MemoryBarrier2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub src_stage_mask: PipelineStageFlags2KHR,
-    pub src_access_mask: AccessFlags2KHR,
-    pub dst_stage_mask: PipelineStageFlags2KHR,
-    pub dst_access_mask: AccessFlags2KHR,
-}
-impl ::std::default::Default for MemoryBarrier2KHR {
-    fn default() -> MemoryBarrier2KHR {
-        MemoryBarrier2KHR {
-            s_type: StructureType::MEMORY_BARRIER_2_KHR,
+    pub src_stage_mask: PipelineStageFlags2,
+    pub src_access_mask: AccessFlags2,
+    pub dst_stage_mask: PipelineStageFlags2,
+    pub dst_access_mask: AccessFlags2,
+}
+impl ::std::default::Default for MemoryBarrier2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            src_stage_mask: PipelineStageFlags2KHR::default(),
-            src_access_mask: AccessFlags2KHR::default(),
-            dst_stage_mask: PipelineStageFlags2KHR::default(),
-            dst_access_mask: AccessFlags2KHR::default(),
+            src_stage_mask: PipelineStageFlags2::default(),
+            src_access_mask: AccessFlags2::default(),
+            dst_stage_mask: PipelineStageFlags2::default(),
+            dst_access_mask: AccessFlags2::default(),
         }
     }
 }
-impl MemoryBarrier2KHR {
-    pub fn builder<'a>() -> MemoryBarrier2KHRBuilder<'a> {
-        MemoryBarrier2KHRBuilder {
-            inner: MemoryBarrier2KHR::default(),
+unsafe impl TaggedStructure for MemoryBarrier2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_BARRIER_2;
+}
+impl MemoryBarrier2 {
+    pub fn builder<'a>() -> MemoryBarrier2Builder<'a> {
+        MemoryBarrier2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct MemoryBarrier2KHRBuilder<'a> {
-    inner: MemoryBarrier2KHR,
+pub struct MemoryBarrier2Builder<'a> {
+    inner: MemoryBarrier2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2KHRBuilder<'_> {}
-unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2KHR {}
-impl<'a> ::std::ops::Deref for MemoryBarrier2KHRBuilder<'a> {
-    type Target = MemoryBarrier2KHR;
+unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2Builder<'_> {}
+unsafe impl ExtendsSubpassDependency2 for MemoryBarrier2 {}
+impl<'a> ::std::ops::Deref for MemoryBarrier2Builder<'a> {
+    type Target = MemoryBarrier2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for MemoryBarrier2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for MemoryBarrier2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> MemoryBarrier2KHRBuilder<'a> {
-    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2KHR) -> Self {
+impl<'a> MemoryBarrier2Builder<'a> {
+    #[inline]
+    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
         self.inner.src_stage_mask = src_stage_mask;
         self
     }
-    pub fn src_access_mask(mut self, src_access_mask: AccessFlags2KHR) -> Self {
+    #[inline]
+    pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
         self.inner.src_access_mask = src_access_mask;
         self
     }
-    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2KHR) -> Self {
+    #[inline]
+    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
         self.inner.dst_stage_mask = dst_stage_mask;
         self
     }
-    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2KHR) -> Self {
+    #[inline]
+    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
         self.inner.dst_access_mask = dst_access_mask;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> MemoryBarrier2KHR {
+    pub fn build(self) -> MemoryBarrier2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageMemoryBarrier2KHR.html>"]
-pub struct ImageMemoryBarrier2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageMemoryBarrier2.html>"]
+pub struct ImageMemoryBarrier2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub src_stage_mask: PipelineStageFlags2KHR,
-    pub src_access_mask: AccessFlags2KHR,
-    pub dst_stage_mask: PipelineStageFlags2KHR,
-    pub dst_access_mask: AccessFlags2KHR,
+    pub src_stage_mask: PipelineStageFlags2,
+    pub src_access_mask: AccessFlags2,
+    pub dst_stage_mask: PipelineStageFlags2,
+    pub dst_access_mask: AccessFlags2,
     pub old_layout: ImageLayout,
     pub new_layout: ImageLayout,
     pub src_queue_family_index: u32,
@@ -45782,15 +54548,16 @@ pub struct ImageMemoryBarrier2KHR {
     pub image: Image,
     pub subresource_range: ImageSubresourceRange,
 }
-impl ::std::default::Default for ImageMemoryBarrier2KHR {
-    fn default() -> ImageMemoryBarrier2KHR {
-        ImageMemoryBarrier2KHR {
-            s_type: StructureType::IMAGE_MEMORY_BARRIER_2_KHR,
+impl ::std::default::Default for ImageMemoryBarrier2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            src_stage_mask: PipelineStageFlags2KHR::default(),
-            src_access_mask: AccessFlags2KHR::default(),
-            dst_stage_mask: PipelineStageFlags2KHR::default(),
-            dst_access_mask: AccessFlags2KHR::default(),
+            src_stage_mask: PipelineStageFlags2::default(),
+            src_access_mask: AccessFlags2::default(),
+            dst_stage_mask: PipelineStageFlags2::default(),
+            dst_access_mask: AccessFlags2::default(),
             old_layout: ImageLayout::default(),
             new_layout: ImageLayout::default(),
             src_queue_family_index: u32::default(),
@@ -45800,68 +54567,81 @@ impl ::std::default::Default for ImageMemoryBarrier2KHR {
         }
     }
 }
-impl ImageMemoryBarrier2KHR {
-    pub fn builder<'a>() -> ImageMemoryBarrier2KHRBuilder<'a> {
-        ImageMemoryBarrier2KHRBuilder {
-            inner: ImageMemoryBarrier2KHR::default(),
+unsafe impl TaggedStructure for ImageMemoryBarrier2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_MEMORY_BARRIER_2;
+}
+impl ImageMemoryBarrier2 {
+    pub fn builder<'a>() -> ImageMemoryBarrier2Builder<'a> {
+        ImageMemoryBarrier2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct ImageMemoryBarrier2KHRBuilder<'a> {
-    inner: ImageMemoryBarrier2KHR,
+pub struct ImageMemoryBarrier2Builder<'a> {
+    inner: ImageMemoryBarrier2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-pub unsafe trait ExtendsImageMemoryBarrier2KHR {}
-impl<'a> ::std::ops::Deref for ImageMemoryBarrier2KHRBuilder<'a> {
-    type Target = ImageMemoryBarrier2KHR;
+pub unsafe trait ExtendsImageMemoryBarrier2 {}
+impl<'a> ::std::ops::Deref for ImageMemoryBarrier2Builder<'a> {
+    type Target = ImageMemoryBarrier2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for ImageMemoryBarrier2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for ImageMemoryBarrier2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> ImageMemoryBarrier2KHRBuilder<'a> {
-    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2KHR) -> Self {
+impl<'a> ImageMemoryBarrier2Builder<'a> {
+    #[inline]
+    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
         self.inner.src_stage_mask = src_stage_mask;
         self
     }
-    pub fn src_access_mask(mut self, src_access_mask: AccessFlags2KHR) -> Self {
+    #[inline]
+    pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
         self.inner.src_access_mask = src_access_mask;
         self
     }
-    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2KHR) -> Self {
+    #[inline]
+    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
         self.inner.dst_stage_mask = dst_stage_mask;
         self
     }
-    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2KHR) -> Self {
+    #[inline]
+    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
         self.inner.dst_access_mask = dst_access_mask;
         self
     }
+    #[inline]
     pub fn old_layout(mut self, old_layout: ImageLayout) -> Self {
         self.inner.old_layout = old_layout;
         self
     }
+    #[inline]
     pub fn new_layout(mut self, new_layout: ImageLayout) -> Self {
         self.inner.new_layout = new_layout;
         self
     }
+    #[inline]
     pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
         self.inner.src_queue_family_index = src_queue_family_index;
         self
     }
+    #[inline]
     pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
         self.inner.dst_queue_family_index = dst_queue_family_index;
         self
     }
+    #[inline]
     pub fn image(mut self, image: Image) -> Self {
         self.inner.image = image;
         self
     }
+    #[inline]
     pub fn subresource_range(mut self, subresource_range: ImageSubresourceRange) -> Self {
         self.inner.subresource_range = subresource_range;
         self
@@ -45871,47 +54651,49 @@ impl<'a> ImageMemoryBarrier2KHRBuilder<'a> {
     #[doc = r" valid extension structs can be pushed into the chain."]
     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
     #[doc = r" chain will look like `A -> D -> B -> C`."]
-    pub fn push_next<T: ExtendsImageMemoryBarrier2KHR>(mut self, next: &'a mut T) -> Self {
+    pub fn push_next<T: ExtendsImageMemoryBarrier2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> ImageMemoryBarrier2KHR {
+    pub fn build(self) -> ImageMemoryBarrier2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBufferMemoryBarrier2KHR.html>"]
-pub struct BufferMemoryBarrier2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferMemoryBarrier2.html>"]
+pub struct BufferMemoryBarrier2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub src_stage_mask: PipelineStageFlags2KHR,
-    pub src_access_mask: AccessFlags2KHR,
-    pub dst_stage_mask: PipelineStageFlags2KHR,
-    pub dst_access_mask: AccessFlags2KHR,
+    pub src_stage_mask: PipelineStageFlags2,
+    pub src_access_mask: AccessFlags2,
+    pub dst_stage_mask: PipelineStageFlags2,
+    pub dst_access_mask: AccessFlags2,
     pub src_queue_family_index: u32,
     pub dst_queue_family_index: u32,
     pub buffer: Buffer,
     pub offset: DeviceSize,
     pub size: DeviceSize,
 }
-impl ::std::default::Default for BufferMemoryBarrier2KHR {
-    fn default() -> BufferMemoryBarrier2KHR {
-        BufferMemoryBarrier2KHR {
-            s_type: StructureType::BUFFER_MEMORY_BARRIER_2_KHR,
+impl ::std::default::Default for BufferMemoryBarrier2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            src_stage_mask: PipelineStageFlags2KHR::default(),
-            src_access_mask: AccessFlags2KHR::default(),
-            dst_stage_mask: PipelineStageFlags2KHR::default(),
-            dst_access_mask: AccessFlags2KHR::default(),
+            src_stage_mask: PipelineStageFlags2::default(),
+            src_access_mask: AccessFlags2::default(),
+            dst_stage_mask: PipelineStageFlags2::default(),
+            dst_access_mask: AccessFlags2::default(),
             src_queue_family_index: u32::default(),
             dst_queue_family_index: u32::default(),
             buffer: Buffer::default(),
@@ -45920,63 +54702,75 @@ impl ::std::default::Default for BufferMemoryBarrier2KHR {
         }
     }
 }
-impl BufferMemoryBarrier2KHR {
-    pub fn builder<'a>() -> BufferMemoryBarrier2KHRBuilder<'a> {
-        BufferMemoryBarrier2KHRBuilder {
-            inner: BufferMemoryBarrier2KHR::default(),
+unsafe impl TaggedStructure for BufferMemoryBarrier2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_MEMORY_BARRIER_2;
+}
+impl BufferMemoryBarrier2 {
+    pub fn builder<'a>() -> BufferMemoryBarrier2Builder<'a> {
+        BufferMemoryBarrier2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct BufferMemoryBarrier2KHRBuilder<'a> {
-    inner: BufferMemoryBarrier2KHR,
+pub struct BufferMemoryBarrier2Builder<'a> {
+    inner: BufferMemoryBarrier2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for BufferMemoryBarrier2KHRBuilder<'a> {
-    type Target = BufferMemoryBarrier2KHR;
+impl<'a> ::std::ops::Deref for BufferMemoryBarrier2Builder<'a> {
+    type Target = BufferMemoryBarrier2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for BufferMemoryBarrier2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for BufferMemoryBarrier2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> BufferMemoryBarrier2KHRBuilder<'a> {
-    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2KHR) -> Self {
+impl<'a> BufferMemoryBarrier2Builder<'a> {
+    #[inline]
+    pub fn src_stage_mask(mut self, src_stage_mask: PipelineStageFlags2) -> Self {
         self.inner.src_stage_mask = src_stage_mask;
         self
     }
-    pub fn src_access_mask(mut self, src_access_mask: AccessFlags2KHR) -> Self {
+    #[inline]
+    pub fn src_access_mask(mut self, src_access_mask: AccessFlags2) -> Self {
         self.inner.src_access_mask = src_access_mask;
         self
     }
-    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2KHR) -> Self {
+    #[inline]
+    pub fn dst_stage_mask(mut self, dst_stage_mask: PipelineStageFlags2) -> Self {
         self.inner.dst_stage_mask = dst_stage_mask;
         self
     }
-    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2KHR) -> Self {
+    #[inline]
+    pub fn dst_access_mask(mut self, dst_access_mask: AccessFlags2) -> Self {
         self.inner.dst_access_mask = dst_access_mask;
         self
     }
+    #[inline]
     pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
         self.inner.src_queue_family_index = src_queue_family_index;
         self
     }
+    #[inline]
     pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
         self.inner.dst_queue_family_index = dst_queue_family_index;
         self
     }
+    #[inline]
     pub fn buffer(mut self, buffer: Buffer) -> Self {
         self.inner.buffer = buffer;
         self
     }
+    #[inline]
     pub fn offset(mut self, offset: DeviceSize) -> Self {
         self.inner.offset = offset;
         self
     }
+    #[inline]
     pub fn size(mut self, size: DeviceSize) -> Self {
         self.inner.size = size;
         self
@@ -45984,28 +54778,30 @@ impl<'a> BufferMemoryBarrier2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> BufferMemoryBarrier2KHR {
+    pub fn build(self) -> BufferMemoryBarrier2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDependencyInfoKHR.html>"]
-pub struct DependencyInfoKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDependencyInfo.html>"]
+pub struct DependencyInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub dependency_flags: DependencyFlags,
     pub memory_barrier_count: u32,
-    pub p_memory_barriers: *const MemoryBarrier2KHR,
+    pub p_memory_barriers: *const MemoryBarrier2,
     pub buffer_memory_barrier_count: u32,
-    pub p_buffer_memory_barriers: *const BufferMemoryBarrier2KHR,
+    pub p_buffer_memory_barriers: *const BufferMemoryBarrier2,
     pub image_memory_barrier_count: u32,
-    pub p_image_memory_barriers: *const ImageMemoryBarrier2KHR,
+    pub p_image_memory_barriers: *const ImageMemoryBarrier2,
 }
-impl ::std::default::Default for DependencyInfoKHR {
-    fn default() -> DependencyInfoKHR {
-        DependencyInfoKHR {
-            s_type: StructureType::DEPENDENCY_INFO_KHR,
+impl ::std::default::Default for DependencyInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             dependency_flags: DependencyFlags::default(),
             memory_barrier_count: u32::default(),
@@ -46017,51 +54813,58 @@ impl ::std::default::Default for DependencyInfoKHR {
         }
     }
 }
-impl DependencyInfoKHR {
-    pub fn builder<'a>() -> DependencyInfoKHRBuilder<'a> {
-        DependencyInfoKHRBuilder {
-            inner: DependencyInfoKHR::default(),
+unsafe impl TaggedStructure for DependencyInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEPENDENCY_INFO;
+}
+impl DependencyInfo {
+    pub fn builder<'a>() -> DependencyInfoBuilder<'a> {
+        DependencyInfoBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct DependencyInfoKHRBuilder<'a> {
-    inner: DependencyInfoKHR,
+pub struct DependencyInfoBuilder<'a> {
+    inner: DependencyInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for DependencyInfoKHRBuilder<'a> {
-    type Target = DependencyInfoKHR;
+impl<'a> ::std::ops::Deref for DependencyInfoBuilder<'a> {
+    type Target = DependencyInfo;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for DependencyInfoKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for DependencyInfoBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> DependencyInfoKHRBuilder<'a> {
+impl<'a> DependencyInfoBuilder<'a> {
+    #[inline]
     pub fn dependency_flags(mut self, dependency_flags: DependencyFlags) -> Self {
         self.inner.dependency_flags = dependency_flags;
         self
     }
-    pub fn memory_barriers(mut self, memory_barriers: &'a [MemoryBarrier2KHR]) -> Self {
+    #[inline]
+    pub fn memory_barriers(mut self, memory_barriers: &'a [MemoryBarrier2]) -> Self {
         self.inner.memory_barrier_count = memory_barriers.len() as _;
         self.inner.p_memory_barriers = memory_barriers.as_ptr();
         self
     }
+    #[inline]
     pub fn buffer_memory_barriers(
         mut self,
-        buffer_memory_barriers: &'a [BufferMemoryBarrier2KHR],
+        buffer_memory_barriers: &'a [BufferMemoryBarrier2],
     ) -> Self {
         self.inner.buffer_memory_barrier_count = buffer_memory_barriers.len() as _;
         self.inner.p_buffer_memory_barriers = buffer_memory_barriers.as_ptr();
         self
     }
+    #[inline]
     pub fn image_memory_barriers(
         mut self,
-        image_memory_barriers: &'a [ImageMemoryBarrier2KHR],
+        image_memory_barriers: &'a [ImageMemoryBarrier2],
     ) -> Self {
         self.inner.image_memory_barrier_count = image_memory_barriers.len() as _;
         self.inner.p_image_memory_barriers = image_memory_barriers.as_ptr();
@@ -46070,70 +54873,79 @@ impl<'a> DependencyInfoKHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> DependencyInfoKHR {
+    pub fn build(self) -> DependencyInfo {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreSubmitInfoKHR.html>"]
-pub struct SemaphoreSubmitInfoKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreSubmitInfo.html>"]
+pub struct SemaphoreSubmitInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub semaphore: Semaphore,
     pub value: u64,
-    pub stage_mask: PipelineStageFlags2KHR,
+    pub stage_mask: PipelineStageFlags2,
     pub device_index: u32,
 }
-impl ::std::default::Default for SemaphoreSubmitInfoKHR {
-    fn default() -> SemaphoreSubmitInfoKHR {
-        SemaphoreSubmitInfoKHR {
-            s_type: StructureType::SEMAPHORE_SUBMIT_INFO_KHR,
+impl ::std::default::Default for SemaphoreSubmitInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             semaphore: Semaphore::default(),
             value: u64::default(),
-            stage_mask: PipelineStageFlags2KHR::default(),
+            stage_mask: PipelineStageFlags2::default(),
             device_index: u32::default(),
         }
     }
 }
-impl SemaphoreSubmitInfoKHR {
-    pub fn builder<'a>() -> SemaphoreSubmitInfoKHRBuilder<'a> {
-        SemaphoreSubmitInfoKHRBuilder {
-            inner: SemaphoreSubmitInfoKHR::default(),
+unsafe impl TaggedStructure for SemaphoreSubmitInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::SEMAPHORE_SUBMIT_INFO;
+}
+impl SemaphoreSubmitInfo {
+    pub fn builder<'a>() -> SemaphoreSubmitInfoBuilder<'a> {
+        SemaphoreSubmitInfoBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct SemaphoreSubmitInfoKHRBuilder<'a> {
-    inner: SemaphoreSubmitInfoKHR,
+pub struct SemaphoreSubmitInfoBuilder<'a> {
+    inner: SemaphoreSubmitInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for SemaphoreSubmitInfoKHRBuilder<'a> {
-    type Target = SemaphoreSubmitInfoKHR;
+impl<'a> ::std::ops::Deref for SemaphoreSubmitInfoBuilder<'a> {
+    type Target = SemaphoreSubmitInfo;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for SemaphoreSubmitInfoKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for SemaphoreSubmitInfoBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> SemaphoreSubmitInfoKHRBuilder<'a> {
+impl<'a> SemaphoreSubmitInfoBuilder<'a> {
+    #[inline]
     pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
         self.inner.semaphore = semaphore;
         self
     }
+    #[inline]
     pub fn value(mut self, value: u64) -> Self {
         self.inner.value = value;
         self
     }
-    pub fn stage_mask(mut self, stage_mask: PipelineStageFlags2KHR) -> Self {
+    #[inline]
+    pub fn stage_mask(mut self, stage_mask: PipelineStageFlags2) -> Self {
         self.inner.stage_mask = stage_mask;
         self
     }
+    #[inline]
     pub fn device_index(mut self, device_index: u32) -> Self {
         self.inner.device_index = device_index;
         self
@@ -46141,58 +54953,65 @@ impl<'a> SemaphoreSubmitInfoKHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> SemaphoreSubmitInfoKHR {
+    pub fn build(self) -> SemaphoreSubmitInfo {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferSubmitInfoKHR.html>"]
-pub struct CommandBufferSubmitInfoKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferSubmitInfo.html>"]
+pub struct CommandBufferSubmitInfo {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub command_buffer: CommandBuffer,
     pub device_mask: u32,
 }
-impl ::std::default::Default for CommandBufferSubmitInfoKHR {
-    fn default() -> CommandBufferSubmitInfoKHR {
-        CommandBufferSubmitInfoKHR {
-            s_type: StructureType::COMMAND_BUFFER_SUBMIT_INFO_KHR,
+impl ::std::default::Default for CommandBufferSubmitInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             command_buffer: CommandBuffer::default(),
             device_mask: u32::default(),
         }
     }
 }
-impl CommandBufferSubmitInfoKHR {
-    pub fn builder<'a>() -> CommandBufferSubmitInfoKHRBuilder<'a> {
-        CommandBufferSubmitInfoKHRBuilder {
-            inner: CommandBufferSubmitInfoKHR::default(),
+unsafe impl TaggedStructure for CommandBufferSubmitInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_SUBMIT_INFO;
+}
+impl CommandBufferSubmitInfo {
+    pub fn builder<'a>() -> CommandBufferSubmitInfoBuilder<'a> {
+        CommandBufferSubmitInfoBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct CommandBufferSubmitInfoKHRBuilder<'a> {
-    inner: CommandBufferSubmitInfoKHR,
+pub struct CommandBufferSubmitInfoBuilder<'a> {
+    inner: CommandBufferSubmitInfo,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for CommandBufferSubmitInfoKHRBuilder<'a> {
-    type Target = CommandBufferSubmitInfoKHR;
+impl<'a> ::std::ops::Deref for CommandBufferSubmitInfoBuilder<'a> {
+    type Target = CommandBufferSubmitInfo;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for CommandBufferSubmitInfoKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for CommandBufferSubmitInfoBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> CommandBufferSubmitInfoKHRBuilder<'a> {
+impl<'a> CommandBufferSubmitInfoBuilder<'a> {
+    #[inline]
     pub fn command_buffer(mut self, command_buffer: CommandBuffer) -> Self {
         self.inner.command_buffer = command_buffer;
         self
     }
+    #[inline]
     pub fn device_mask(mut self, device_mask: u32) -> Self {
         self.inner.device_mask = device_mask;
         self
@@ -46200,30 +55019,32 @@ impl<'a> CommandBufferSubmitInfoKHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> CommandBufferSubmitInfoKHR {
+    pub fn build(self) -> CommandBufferSubmitInfo {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubmitInfo2KHR.html>"]
-pub struct SubmitInfo2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubmitInfo2.html>"]
+pub struct SubmitInfo2 {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub flags: SubmitFlagsKHR,
+    pub flags: SubmitFlags,
     pub wait_semaphore_info_count: u32,
-    pub p_wait_semaphore_infos: *const SemaphoreSubmitInfoKHR,
+    pub p_wait_semaphore_infos: *const SemaphoreSubmitInfo,
     pub command_buffer_info_count: u32,
-    pub p_command_buffer_infos: *const CommandBufferSubmitInfoKHR,
+    pub p_command_buffer_infos: *const CommandBufferSubmitInfo,
     pub signal_semaphore_info_count: u32,
-    pub p_signal_semaphore_infos: *const SemaphoreSubmitInfoKHR,
+    pub p_signal_semaphore_infos: *const SemaphoreSubmitInfo,
 }
-impl ::std::default::Default for SubmitInfo2KHR {
-    fn default() -> SubmitInfo2KHR {
-        SubmitInfo2KHR {
-            s_type: StructureType::SUBMIT_INFO_2_KHR,
+impl ::std::default::Default for SubmitInfo2 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            flags: SubmitFlagsKHR::default(),
+            flags: SubmitFlags::default(),
             wait_semaphore_info_count: u32::default(),
             p_wait_semaphore_infos: ::std::ptr::null(),
             command_buffer_info_count: u32::default(),
@@ -46233,55 +55054,59 @@ impl ::std::default::Default for SubmitInfo2KHR {
         }
     }
 }
-impl SubmitInfo2KHR {
-    pub fn builder<'a>() -> SubmitInfo2KHRBuilder<'a> {
-        SubmitInfo2KHRBuilder {
-            inner: SubmitInfo2KHR::default(),
+unsafe impl TaggedStructure for SubmitInfo2 {
+    const STRUCTURE_TYPE: StructureType = StructureType::SUBMIT_INFO_2;
+}
+impl SubmitInfo2 {
+    pub fn builder<'a>() -> SubmitInfo2Builder<'a> {
+        SubmitInfo2Builder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct SubmitInfo2KHRBuilder<'a> {
-    inner: SubmitInfo2KHR,
+pub struct SubmitInfo2Builder<'a> {
+    inner: SubmitInfo2,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-pub unsafe trait ExtendsSubmitInfo2KHR {}
-impl<'a> ::std::ops::Deref for SubmitInfo2KHRBuilder<'a> {
-    type Target = SubmitInfo2KHR;
+pub unsafe trait ExtendsSubmitInfo2 {}
+impl<'a> ::std::ops::Deref for SubmitInfo2Builder<'a> {
+    type Target = SubmitInfo2;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for SubmitInfo2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for SubmitInfo2Builder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> SubmitInfo2KHRBuilder<'a> {
-    pub fn flags(mut self, flags: SubmitFlagsKHR) -> Self {
+impl<'a> SubmitInfo2Builder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: SubmitFlags) -> Self {
         self.inner.flags = flags;
         self
     }
-    pub fn wait_semaphore_infos(
-        mut self,
-        wait_semaphore_infos: &'a [SemaphoreSubmitInfoKHR],
-    ) -> Self {
+    #[inline]
+    pub fn wait_semaphore_infos(mut self, wait_semaphore_infos: &'a [SemaphoreSubmitInfo]) -> Self {
         self.inner.wait_semaphore_info_count = wait_semaphore_infos.len() as _;
         self.inner.p_wait_semaphore_infos = wait_semaphore_infos.as_ptr();
         self
     }
+    #[inline]
     pub fn command_buffer_infos(
         mut self,
-        command_buffer_infos: &'a [CommandBufferSubmitInfoKHR],
+        command_buffer_infos: &'a [CommandBufferSubmitInfo],
     ) -> Self {
         self.inner.command_buffer_info_count = command_buffer_infos.len() as _;
         self.inner.p_command_buffer_infos = command_buffer_infos.as_ptr();
         self
     }
+    #[inline]
     pub fn signal_semaphore_infos(
         mut self,
-        signal_semaphore_infos: &'a [SemaphoreSubmitInfoKHR],
+        signal_semaphore_infos: &'a [SemaphoreSubmitInfo],
     ) -> Self {
         self.inner.signal_semaphore_info_count = signal_semaphore_infos.len() as _;
         self.inner.p_signal_semaphore_infos = signal_semaphore_infos.as_ptr();
@@ -46292,43 +55117,48 @@ impl<'a> SubmitInfo2KHRBuilder<'a> {
     #[doc = r" valid extension structs can be pushed into the chain."]
     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
     #[doc = r" chain will look like `A -> D -> B -> C`."]
-    pub fn push_next<T: ExtendsSubmitInfo2KHR>(mut self, next: &'a mut T) -> Self {
+    pub fn push_next<T: ExtendsSubmitInfo2>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> SubmitInfo2KHR {
+    pub fn build(self) -> SubmitInfo2 {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueFamilyCheckpointProperties2NV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyCheckpointProperties2NV.html>"]
 pub struct QueueFamilyCheckpointProperties2NV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
-    pub checkpoint_execution_stage_mask: PipelineStageFlags2KHR,
+    pub checkpoint_execution_stage_mask: PipelineStageFlags2,
 }
 impl ::std::default::Default for QueueFamilyCheckpointProperties2NV {
-    fn default() -> QueueFamilyCheckpointProperties2NV {
-        QueueFamilyCheckpointProperties2NV {
-            s_type: StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
-            checkpoint_execution_stage_mask: PipelineStageFlags2KHR::default(),
+            checkpoint_execution_stage_mask: PipelineStageFlags2::default(),
         }
     }
 }
+unsafe impl TaggedStructure for QueueFamilyCheckpointProperties2NV {
+    const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV;
+}
 impl QueueFamilyCheckpointProperties2NV {
     pub fn builder<'a>() -> QueueFamilyCheckpointProperties2NVBuilder<'a> {
         QueueFamilyCheckpointProperties2NVBuilder {
-            inner: QueueFamilyCheckpointProperties2NV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -46352,9 +55182,10 @@ impl<'a> ::std::ops::DerefMut for QueueFamilyCheckpointProperties2NVBuilder<'a>
     }
 }
 impl<'a> QueueFamilyCheckpointProperties2NVBuilder<'a> {
+    #[inline]
     pub fn checkpoint_execution_stage_mask(
         mut self,
-        checkpoint_execution_stage_mask: PipelineStageFlags2KHR,
+        checkpoint_execution_stage_mask: PipelineStageFlags2,
     ) -> Self {
         self.inner.checkpoint_execution_stage_mask = checkpoint_execution_stage_mask;
         self
@@ -46367,28 +55198,33 @@ impl<'a> QueueFamilyCheckpointProperties2NVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCheckpointData2NV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCheckpointData2NV.html>"]
 pub struct CheckpointData2NV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
-    pub stage: PipelineStageFlags2KHR,
+    pub stage: PipelineStageFlags2,
     pub p_checkpoint_marker: *mut c_void,
 }
 impl ::std::default::Default for CheckpointData2NV {
-    fn default() -> CheckpointData2NV {
-        CheckpointData2NV {
-            s_type: StructureType::CHECKPOINT_DATA_2_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
-            stage: PipelineStageFlags2KHR::default(),
+            stage: PipelineStageFlags2::default(),
             p_checkpoint_marker: ::std::ptr::null_mut(),
         }
     }
 }
+unsafe impl TaggedStructure for CheckpointData2NV {
+    const STRUCTURE_TYPE: StructureType = StructureType::CHECKPOINT_DATA_2_NV;
+}
 impl CheckpointData2NV {
     pub fn builder<'a>() -> CheckpointData2NVBuilder<'a> {
         CheckpointData2NVBuilder {
-            inner: CheckpointData2NV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -46410,10 +55246,12 @@ impl<'a> ::std::ops::DerefMut for CheckpointData2NVBuilder<'a> {
     }
 }
 impl<'a> CheckpointData2NVBuilder<'a> {
-    pub fn stage(mut self, stage: PipelineStageFlags2KHR) -> Self {
+    #[inline]
+    pub fn stage(mut self, stage: PipelineStageFlags2) -> Self {
         self.inner.stage = stage;
         self
     }
+    #[inline]
     pub fn checkpoint_marker(mut self, checkpoint_marker: *mut c_void) -> Self {
         self.inner.p_checkpoint_marker = checkpoint_marker;
         self
@@ -46426,109 +55264,562 @@ impl<'a> CheckpointData2NVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceSynchronization2FeaturesKHR.html>"]
-pub struct PhysicalDeviceSynchronization2FeaturesKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSynchronization2Features.html>"]
+pub struct PhysicalDeviceSynchronization2Features {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub synchronization2: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceSynchronization2FeaturesKHR {
-    fn default() -> PhysicalDeviceSynchronization2FeaturesKHR {
-        PhysicalDeviceSynchronization2FeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR,
+impl ::std::default::Default for PhysicalDeviceSynchronization2Features {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             synchronization2: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceSynchronization2FeaturesKHR {
-    pub fn builder<'a>() -> PhysicalDeviceSynchronization2FeaturesKHRBuilder<'a> {
-        PhysicalDeviceSynchronization2FeaturesKHRBuilder {
-            inner: PhysicalDeviceSynchronization2FeaturesKHR::default(),
+unsafe impl TaggedStructure for PhysicalDeviceSynchronization2Features {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
+}
+impl PhysicalDeviceSynchronization2Features {
+    pub fn builder<'a>() -> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
+        PhysicalDeviceSynchronization2FeaturesBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
+    inner: PhysicalDeviceSynchronization2Features,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2Features {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2Features {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
+    type Target = PhysicalDeviceSynchronization2Features;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceSynchronization2FeaturesBuilder<'a> {
+    #[inline]
+    pub fn synchronization2(mut self, synchronization2: bool) -> Self {
+        self.inner.synchronization2 = synchronization2.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceSynchronization2Features {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.html>"]
+pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub primitives_generated_query: Bool32,
+    pub primitives_generated_query_with_rasterizer_discard: Bool32,
+    pub primitives_generated_query_with_non_zero_streams: Bool32,
+}
+impl ::std::default::Default for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            primitives_generated_query: Bool32::default(),
+            primitives_generated_query_with_rasterizer_discard: Bool32::default(),
+            primitives_generated_query_with_non_zero_streams: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT;
+}
+impl PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
+        PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceSynchronization2FeaturesKHRBuilder<'a> {
-    inner: PhysicalDeviceSynchronization2FeaturesKHR,
+pub struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
+    inner: PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceSynchronization2FeaturesKHRBuilder<'_>
+    for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'_>
 {
 }
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSynchronization2FeaturesKHR {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesKHRBuilder<'_> {}
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSynchronization2FeaturesKHR {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceSynchronization2FeaturesKHRBuilder<'a> {
-    type Target = PhysicalDeviceSynchronization2FeaturesKHR;
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceSynchronization2FeaturesKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceSynchronization2FeaturesKHRBuilder<'a> {
-    pub fn synchronization2(mut self, synchronization2: bool) -> Self {
-        self.inner.synchronization2 = synchronization2.into();
+impl<'a> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn primitives_generated_query(mut self, primitives_generated_query: bool) -> Self {
+        self.inner.primitives_generated_query = primitives_generated_query.into();
+        self
+    }
+    #[inline]
+    pub fn primitives_generated_query_with_rasterizer_discard(
+        mut self,
+        primitives_generated_query_with_rasterizer_discard: bool,
+    ) -> Self {
+        self.inner
+            .primitives_generated_query_with_rasterizer_discard =
+            primitives_generated_query_with_rasterizer_discard.into();
+        self
+    }
+    #[inline]
+    pub fn primitives_generated_query_with_non_zero_streams(
+        mut self,
+        primitives_generated_query_with_non_zero_streams: bool,
+    ) -> Self {
+        self.inner.primitives_generated_query_with_non_zero_streams =
+            primitives_generated_query_with_non_zero_streams.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLegacyDitheringFeaturesEXT.html>"]
+pub struct PhysicalDeviceLegacyDitheringFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub legacy_dithering: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceLegacyDitheringFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            legacy_dithering: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceLegacyDitheringFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT;
+}
+impl PhysicalDeviceLegacyDitheringFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
+        PhysicalDeviceLegacyDitheringFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceLegacyDitheringFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLegacyDitheringFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLegacyDitheringFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceLegacyDitheringFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceLegacyDitheringFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn legacy_dithering(mut self, legacy_dithering: bool) -> Self {
+        self.inner.legacy_dithering = legacy_dithering.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceLegacyDitheringFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.html>"]
+pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub multisampled_render_to_single_sampled: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            multisampled_render_to_single_sampled: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT;
+}
+impl PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
+        PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {}
+impl<'a> ::std::ops::Deref
+    for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a>
+{
+    type Target = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut
+    for PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a>
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn multisampled_render_to_single_sampled(
+        mut self,
+        multisampled_render_to_single_sampled: bool,
+    ) -> Self {
+        self.inner.multisampled_render_to_single_sampled =
+            multisampled_render_to_single_sampled.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassResolvePerformanceQueryEXT.html>"]
+pub struct SubpassResolvePerformanceQueryEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub optimal: Bool32,
+}
+impl ::std::default::Default for SubpassResolvePerformanceQueryEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            optimal: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SubpassResolvePerformanceQueryEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
+}
+impl SubpassResolvePerformanceQueryEXT {
+    pub fn builder<'a>() -> SubpassResolvePerformanceQueryEXTBuilder<'a> {
+        SubpassResolvePerformanceQueryEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SubpassResolvePerformanceQueryEXTBuilder<'a> {
+    inner: SubpassResolvePerformanceQueryEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXTBuilder<'_> {}
+unsafe impl ExtendsFormatProperties2 for SubpassResolvePerformanceQueryEXT {}
+impl<'a> ::std::ops::Deref for SubpassResolvePerformanceQueryEXTBuilder<'a> {
+    type Target = SubpassResolvePerformanceQueryEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SubpassResolvePerformanceQueryEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SubpassResolvePerformanceQueryEXTBuilder<'a> {
+    #[inline]
+    pub fn optimal(mut self, optimal: bool) -> Self {
+        self.inner.optimal = optimal.into();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceSynchronization2FeaturesKHR {
+    pub fn build(self) -> SubpassResolvePerformanceQueryEXT {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoQueueFamilyProperties2KHR.html>"]
-pub struct VideoQueueFamilyProperties2KHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultisampledRenderToSingleSampledInfoEXT.html>"]
+pub struct MultisampledRenderToSingleSampledInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub multisampled_render_to_single_sampled_enable: Bool32,
+    pub rasterization_samples: SampleCountFlags,
+}
+impl ::std::default::Default for MultisampledRenderToSingleSampledInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            multisampled_render_to_single_sampled_enable: Bool32::default(),
+            rasterization_samples: SampleCountFlags::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for MultisampledRenderToSingleSampledInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT;
+}
+impl MultisampledRenderToSingleSampledInfoEXT {
+    pub fn builder<'a>() -> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
+        MultisampledRenderToSingleSampledInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
+    inner: MultisampledRenderToSingleSampledInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {}
+unsafe impl ExtendsSubpassDescription2 for MultisampledRenderToSingleSampledInfoEXT {}
+unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXTBuilder<'_> {}
+unsafe impl ExtendsRenderingInfo for MultisampledRenderToSingleSampledInfoEXT {}
+impl<'a> ::std::ops::Deref for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
+    type Target = MultisampledRenderToSingleSampledInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MultisampledRenderToSingleSampledInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn multisampled_render_to_single_sampled_enable(
+        mut self,
+        multisampled_render_to_single_sampled_enable: bool,
+    ) -> Self {
+        self.inner.multisampled_render_to_single_sampled_enable =
+            multisampled_render_to_single_sampled_enable.into();
+        self
+    }
+    #[inline]
+    pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
+        self.inner.rasterization_samples = rasterization_samples;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MultisampledRenderToSingleSampledInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineProtectedAccessFeaturesEXT.html>"]
+pub struct PhysicalDevicePipelineProtectedAccessFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub pipeline_protected_access: Bool32,
+}
+impl ::std::default::Default for PhysicalDevicePipelineProtectedAccessFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            pipeline_protected_access: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDevicePipelineProtectedAccessFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT;
+}
+impl PhysicalDevicePipelineProtectedAccessFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
+        PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
+    inner: PhysicalDevicePipelineProtectedAccessFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineProtectedAccessFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineProtectedAccessFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDevicePipelineProtectedAccessFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDevicePipelineProtectedAccessFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn pipeline_protected_access(mut self, pipeline_protected_access: bool) -> Self {
+        self.inner.pipeline_protected_access = pipeline_protected_access.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDevicePipelineProtectedAccessFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyVideoPropertiesKHR.html>"]
+pub struct QueueFamilyVideoPropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub video_codec_operations: VideoCodecOperationFlagsKHR,
 }
-impl ::std::default::Default for VideoQueueFamilyProperties2KHR {
-    fn default() -> VideoQueueFamilyProperties2KHR {
-        VideoQueueFamilyProperties2KHR {
-            s_type: StructureType::VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR,
+impl ::std::default::Default for QueueFamilyVideoPropertiesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             video_codec_operations: VideoCodecOperationFlagsKHR::default(),
         }
     }
 }
-impl VideoQueueFamilyProperties2KHR {
-    pub fn builder<'a>() -> VideoQueueFamilyProperties2KHRBuilder<'a> {
-        VideoQueueFamilyProperties2KHRBuilder {
-            inner: VideoQueueFamilyProperties2KHR::default(),
+unsafe impl TaggedStructure for QueueFamilyVideoPropertiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
+}
+impl QueueFamilyVideoPropertiesKHR {
+    pub fn builder<'a>() -> QueueFamilyVideoPropertiesKHRBuilder<'a> {
+        QueueFamilyVideoPropertiesKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoQueueFamilyProperties2KHRBuilder<'a> {
-    inner: VideoQueueFamilyProperties2KHR,
+pub struct QueueFamilyVideoPropertiesKHRBuilder<'a> {
+    inner: QueueFamilyVideoPropertiesKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsQueueFamilyProperties2 for VideoQueueFamilyProperties2KHRBuilder<'_> {}
-unsafe impl ExtendsQueueFamilyProperties2 for VideoQueueFamilyProperties2KHR {}
-impl<'a> ::std::ops::Deref for VideoQueueFamilyProperties2KHRBuilder<'a> {
-    type Target = VideoQueueFamilyProperties2KHR;
+unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyVideoPropertiesKHRBuilder<'_> {}
+unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyVideoPropertiesKHR {}
+impl<'a> ::std::ops::Deref for QueueFamilyVideoPropertiesKHRBuilder<'a> {
+    type Target = QueueFamilyVideoPropertiesKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoQueueFamilyProperties2KHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for QueueFamilyVideoPropertiesKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoQueueFamilyProperties2KHRBuilder<'a> {
+impl<'a> QueueFamilyVideoPropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn video_codec_operations(
         mut self,
         video_codec_operations: VideoCodecOperationFlagsKHR,
@@ -46539,100 +55830,168 @@ impl<'a> VideoQueueFamilyProperties2KHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoQueueFamilyProperties2KHR {
+    pub fn build(self) -> QueueFamilyVideoPropertiesKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoProfilesKHR.html>"]
-pub struct VideoProfilesKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueFamilyQueryResultStatusPropertiesKHR.html>"]
+pub struct QueueFamilyQueryResultStatusPropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
-    pub profile_count: u32,
-    pub p_profiles: *const VideoProfileKHR,
+    pub query_result_status_support: Bool32,
 }
-impl ::std::default::Default for VideoProfilesKHR {
-    fn default() -> VideoProfilesKHR {
-        VideoProfilesKHR {
-            s_type: StructureType::VIDEO_PROFILES_KHR,
+impl ::std::default::Default for QueueFamilyQueryResultStatusPropertiesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
-            profile_count: u32::default(),
-            p_profiles: ::std::ptr::null(),
+            query_result_status_support: Bool32::default(),
         }
     }
 }
-impl VideoProfilesKHR {
-    pub fn builder<'a>() -> VideoProfilesKHRBuilder<'a> {
-        VideoProfilesKHRBuilder {
-            inner: VideoProfilesKHR::default(),
+unsafe impl TaggedStructure for QueueFamilyQueryResultStatusPropertiesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR;
+}
+impl QueueFamilyQueryResultStatusPropertiesKHR {
+    pub fn builder<'a>() -> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
+        QueueFamilyQueryResultStatusPropertiesKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoProfilesKHRBuilder<'a> {
-    inner: VideoProfilesKHR,
+pub struct QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
+    inner: QueueFamilyQueryResultStatusPropertiesKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsFormatProperties2 for VideoProfilesKHRBuilder<'_> {}
-unsafe impl ExtendsFormatProperties2 for VideoProfilesKHR {}
-unsafe impl ExtendsImageCreateInfo for VideoProfilesKHRBuilder<'_> {}
-unsafe impl ExtendsImageCreateInfo for VideoProfilesKHR {}
-unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHRBuilder<'_> {}
-unsafe impl ExtendsImageViewCreateInfo for VideoProfilesKHR {}
-unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHRBuilder<'_> {}
-unsafe impl ExtendsBufferCreateInfo for VideoProfilesKHR {}
-impl<'a> ::std::ops::Deref for VideoProfilesKHRBuilder<'a> {
-    type Target = VideoProfilesKHR;
+unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'_> {}
+unsafe impl ExtendsQueueFamilyProperties2 for QueueFamilyQueryResultStatusPropertiesKHR {}
+impl<'a> ::std::ops::Deref for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
+    type Target = QueueFamilyQueryResultStatusPropertiesKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoProfilesKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoProfilesKHRBuilder<'a> {
-    pub fn profile_count(mut self, profile_count: u32) -> Self {
-        self.inner.profile_count = profile_count;
+impl<'a> QueueFamilyQueryResultStatusPropertiesKHRBuilder<'a> {
+    #[inline]
+    pub fn query_result_status_support(mut self, query_result_status_support: bool) -> Self {
+        self.inner.query_result_status_support = query_result_status_support.into();
         self
     }
-    pub fn profiles(mut self, profiles: &'a VideoProfileKHR) -> Self {
-        self.inner.p_profiles = profiles;
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> QueueFamilyQueryResultStatusPropertiesKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileListInfoKHR.html>"]
+pub struct VideoProfileListInfoKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub profile_count: u32,
+    pub p_profiles: *const VideoProfileInfoKHR,
+}
+impl ::std::default::Default for VideoProfileListInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            profile_count: u32::default(),
+            p_profiles: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoProfileListInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PROFILE_LIST_INFO_KHR;
+}
+impl VideoProfileListInfoKHR {
+    pub fn builder<'a>() -> VideoProfileListInfoKHRBuilder<'a> {
+        VideoProfileListInfoKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoProfileListInfoKHRBuilder<'a> {
+    inner: VideoProfileListInfoKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfileListInfoKHRBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for VideoProfileListInfoKHR {}
+unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfileListInfoKHRBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceVideoFormatInfoKHR for VideoProfileListInfoKHR {}
+unsafe impl ExtendsImageCreateInfo for VideoProfileListInfoKHRBuilder<'_> {}
+unsafe impl ExtendsImageCreateInfo for VideoProfileListInfoKHR {}
+unsafe impl ExtendsBufferCreateInfo for VideoProfileListInfoKHRBuilder<'_> {}
+unsafe impl ExtendsBufferCreateInfo for VideoProfileListInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoProfileListInfoKHRBuilder<'a> {
+    type Target = VideoProfileListInfoKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoProfileListInfoKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoProfileListInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn profiles(mut self, profiles: &'a [VideoProfileInfoKHR]) -> Self {
+        self.inner.profile_count = profiles.len() as _;
+        self.inner.p_profiles = profiles.as_ptr();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoProfilesKHR {
+    pub fn build(self) -> VideoProfileListInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html>"]
 pub struct PhysicalDeviceVideoFormatInfoKHR {
     pub s_type: StructureType,
-    pub p_next: *mut c_void,
+    pub p_next: *const c_void,
     pub image_usage: ImageUsageFlags,
-    pub p_video_profiles: *const VideoProfilesKHR,
 }
 impl ::std::default::Default for PhysicalDeviceVideoFormatInfoKHR {
-    fn default() -> PhysicalDeviceVideoFormatInfoKHR {
-        PhysicalDeviceVideoFormatInfoKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
-            p_next: ::std::ptr::null_mut(),
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
             image_usage: ImageUsageFlags::default(),
-            p_video_profiles: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceVideoFormatInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR;
+}
 impl PhysicalDeviceVideoFormatInfoKHR {
     pub fn builder<'a>() -> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
         PhysicalDeviceVideoFormatInfoKHRBuilder {
-            inner: PhysicalDeviceVideoFormatInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -46642,6 +56001,7 @@ pub struct PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
     inner: PhysicalDeviceVideoFormatInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+pub unsafe trait ExtendsPhysicalDeviceVideoFormatInfoKHR {}
 impl<'a> ::std::ops::Deref for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
     type Target = PhysicalDeviceVideoFormatInfoKHR;
     fn deref(&self) -> &Self::Target {
@@ -46654,12 +56014,26 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
+    #[inline]
     pub fn image_usage(mut self, image_usage: ImageUsageFlags) -> Self {
         self.inner.image_usage = image_usage;
         self
     }
-    pub fn video_profiles(mut self, video_profiles: &'a VideoProfilesKHR) -> Self {
-        self.inner.p_video_profiles = video_profiles;
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsPhysicalDeviceVideoFormatInfoKHR>(
+        mut self,
+        next: &'a mut T,
+    ) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -46670,26 +56044,41 @@ impl<'a> PhysicalDeviceVideoFormatInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoFormatPropertiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoFormatPropertiesKHR.html>"]
 pub struct VideoFormatPropertiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub format: Format,
+    pub component_mapping: ComponentMapping,
+    pub image_create_flags: ImageCreateFlags,
+    pub image_type: ImageType,
+    pub image_tiling: ImageTiling,
+    pub image_usage_flags: ImageUsageFlags,
 }
 impl ::std::default::Default for VideoFormatPropertiesKHR {
-    fn default() -> VideoFormatPropertiesKHR {
-        VideoFormatPropertiesKHR {
-            s_type: StructureType::VIDEO_FORMAT_PROPERTIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             format: Format::default(),
+            component_mapping: ComponentMapping::default(),
+            image_create_flags: ImageCreateFlags::default(),
+            image_type: ImageType::default(),
+            image_tiling: ImageTiling::default(),
+            image_usage_flags: ImageUsageFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoFormatPropertiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_FORMAT_PROPERTIES_KHR;
+}
 impl VideoFormatPropertiesKHR {
     pub fn builder<'a>() -> VideoFormatPropertiesKHRBuilder<'a> {
         VideoFormatPropertiesKHRBuilder {
-            inner: VideoFormatPropertiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -46711,10 +56100,36 @@ impl<'a> ::std::ops::DerefMut for VideoFormatPropertiesKHRBuilder<'a> {
     }
 }
 impl<'a> VideoFormatPropertiesKHRBuilder<'a> {
+    #[inline]
     pub fn format(mut self, format: Format) -> Self {
         self.inner.format = format;
         self
     }
+    #[inline]
+    pub fn component_mapping(mut self, component_mapping: ComponentMapping) -> Self {
+        self.inner.component_mapping = component_mapping;
+        self
+    }
+    #[inline]
+    pub fn image_create_flags(mut self, image_create_flags: ImageCreateFlags) -> Self {
+        self.inner.image_create_flags = image_create_flags;
+        self
+    }
+    #[inline]
+    pub fn image_type(mut self, image_type: ImageType) -> Self {
+        self.inner.image_type = image_type;
+        self
+    }
+    #[inline]
+    pub fn image_tiling(mut self, image_tiling: ImageTiling) -> Self {
+        self.inner.image_tiling = image_tiling;
+        self
+    }
+    #[inline]
+    pub fn image_usage_flags(mut self, image_usage_flags: ImageUsageFlags) -> Self {
+        self.inner.image_usage_flags = image_usage_flags;
+        self
+    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
@@ -46723,21 +56138,23 @@ impl<'a> VideoFormatPropertiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoProfileKHR.html>"]
-pub struct VideoProfileKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoProfileInfoKHR.html>"]
+pub struct VideoProfileInfoKHR {
     pub s_type: StructureType,
-    pub p_next: *mut c_void,
+    pub p_next: *const c_void,
     pub video_codec_operation: VideoCodecOperationFlagsKHR,
     pub chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
     pub luma_bit_depth: VideoComponentBitDepthFlagsKHR,
     pub chroma_bit_depth: VideoComponentBitDepthFlagsKHR,
 }
-impl ::std::default::Default for VideoProfileKHR {
-    fn default() -> VideoProfileKHR {
-        VideoProfileKHR {
-            s_type: StructureType::VIDEO_PROFILE_KHR,
-            p_next: ::std::ptr::null_mut(),
+impl ::std::default::Default for VideoProfileInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
             video_codec_operation: VideoCodecOperationFlagsKHR::default(),
             chroma_subsampling: VideoChromaSubsamplingFlagsKHR::default(),
             luma_bit_depth: VideoComponentBitDepthFlagsKHR::default(),
@@ -46745,42 +56162,38 @@ impl ::std::default::Default for VideoProfileKHR {
         }
     }
 }
-impl VideoProfileKHR {
-    pub fn builder<'a>() -> VideoProfileKHRBuilder<'a> {
-        VideoProfileKHRBuilder {
-            inner: VideoProfileKHR::default(),
+unsafe impl TaggedStructure for VideoProfileInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PROFILE_INFO_KHR;
+}
+impl VideoProfileInfoKHR {
+    pub fn builder<'a>() -> VideoProfileInfoKHRBuilder<'a> {
+        VideoProfileInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoProfileKHRBuilder<'a> {
-    inner: VideoProfileKHR,
+pub struct VideoProfileInfoKHRBuilder<'a> {
+    inner: VideoProfileInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHRBuilder<'_> {}
-unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileKHR {}
-unsafe impl ExtendsFormatProperties2 for VideoProfileKHRBuilder<'_> {}
-unsafe impl ExtendsFormatProperties2 for VideoProfileKHR {}
-unsafe impl ExtendsImageCreateInfo for VideoProfileKHRBuilder<'_> {}
-unsafe impl ExtendsImageCreateInfo for VideoProfileKHR {}
-unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHRBuilder<'_> {}
-unsafe impl ExtendsImageViewCreateInfo for VideoProfileKHR {}
-unsafe impl ExtendsBufferCreateInfo for VideoProfileKHRBuilder<'_> {}
-unsafe impl ExtendsBufferCreateInfo for VideoProfileKHR {}
-pub unsafe trait ExtendsVideoProfileKHR {}
-impl<'a> ::std::ops::Deref for VideoProfileKHRBuilder<'a> {
-    type Target = VideoProfileKHR;
+unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileInfoKHRBuilder<'_> {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoProfileInfoKHR {}
+pub unsafe trait ExtendsVideoProfileInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoProfileInfoKHRBuilder<'a> {
+    type Target = VideoProfileInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoProfileKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoProfileInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoProfileKHRBuilder<'a> {
+impl<'a> VideoProfileInfoKHRBuilder<'a> {
+    #[inline]
     pub fn video_codec_operation(
         mut self,
         video_codec_operation: VideoCodecOperationFlagsKHR,
@@ -46788,6 +56201,7 @@ impl<'a> VideoProfileKHRBuilder<'a> {
         self.inner.video_codec_operation = video_codec_operation;
         self
     }
+    #[inline]
     pub fn chroma_subsampling(
         mut self,
         chroma_subsampling: VideoChromaSubsamplingFlagsKHR,
@@ -46795,10 +56209,12 @@ impl<'a> VideoProfileKHRBuilder<'a> {
         self.inner.chroma_subsampling = chroma_subsampling;
         self
     }
+    #[inline]
     pub fn luma_bit_depth(mut self, luma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self {
         self.inner.luma_bit_depth = luma_bit_depth;
         self
     }
+    #[inline]
     pub fn chroma_bit_depth(mut self, chroma_bit_depth: VideoComponentBitDepthFlagsKHR) -> Self {
         self.inner.chroma_bit_depth = chroma_bit_depth;
         self
@@ -46808,57 +56224,64 @@ impl<'a> VideoProfileKHRBuilder<'a> {
     #[doc = r" valid extension structs can be pushed into the chain."]
     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
     #[doc = r" chain will look like `A -> D -> B -> C`."]
-    pub fn push_next<T: ExtendsVideoProfileKHR>(mut self, next: &'a mut T) -> Self {
+    pub fn push_next<T: ExtendsVideoProfileInfoKHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoProfileKHR {
+    pub fn build(self) -> VideoProfileInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCapabilitiesKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCapabilitiesKHR.html>"]
 pub struct VideoCapabilitiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
-    pub capability_flags: VideoCapabilityFlagsKHR,
+    pub flags: VideoCapabilityFlagsKHR,
     pub min_bitstream_buffer_offset_alignment: DeviceSize,
     pub min_bitstream_buffer_size_alignment: DeviceSize,
-    pub video_picture_extent_granularity: Extent2D,
-    pub min_extent: Extent2D,
-    pub max_extent: Extent2D,
-    pub max_reference_pictures_slots_count: u32,
-    pub max_reference_pictures_active_count: u32,
+    pub picture_access_granularity: Extent2D,
+    pub min_coded_extent: Extent2D,
+    pub max_coded_extent: Extent2D,
+    pub max_dpb_slots: u32,
+    pub max_active_reference_pictures: u32,
+    pub std_header_version: ExtensionProperties,
 }
 impl ::std::default::Default for VideoCapabilitiesKHR {
-    fn default() -> VideoCapabilitiesKHR {
-        VideoCapabilitiesKHR {
-            s_type: StructureType::VIDEO_CAPABILITIES_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
-            capability_flags: VideoCapabilityFlagsKHR::default(),
+            flags: VideoCapabilityFlagsKHR::default(),
             min_bitstream_buffer_offset_alignment: DeviceSize::default(),
             min_bitstream_buffer_size_alignment: DeviceSize::default(),
-            video_picture_extent_granularity: Extent2D::default(),
-            min_extent: Extent2D::default(),
-            max_extent: Extent2D::default(),
-            max_reference_pictures_slots_count: u32::default(),
-            max_reference_pictures_active_count: u32::default(),
+            picture_access_granularity: Extent2D::default(),
+            min_coded_extent: Extent2D::default(),
+            max_coded_extent: Extent2D::default(),
+            max_dpb_slots: u32::default(),
+            max_active_reference_pictures: u32::default(),
+            std_header_version: ExtensionProperties::default(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoCapabilitiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_CAPABILITIES_KHR;
+}
 impl VideoCapabilitiesKHR {
     pub fn builder<'a>() -> VideoCapabilitiesKHRBuilder<'a> {
         VideoCapabilitiesKHRBuilder {
-            inner: VideoCapabilitiesKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -46881,10 +56304,12 @@ impl<'a> ::std::ops::DerefMut for VideoCapabilitiesKHRBuilder<'a> {
     }
 }
 impl<'a> VideoCapabilitiesKHRBuilder<'a> {
-    pub fn capability_flags(mut self, capability_flags: VideoCapabilityFlagsKHR) -> Self {
-        self.inner.capability_flags = capability_flags;
+    #[inline]
+    pub fn flags(mut self, flags: VideoCapabilityFlagsKHR) -> Self {
+        self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn min_bitstream_buffer_offset_alignment(
         mut self,
         min_bitstream_buffer_offset_alignment: DeviceSize,
@@ -46892,6 +56317,7 @@ impl<'a> VideoCapabilitiesKHRBuilder<'a> {
         self.inner.min_bitstream_buffer_offset_alignment = min_bitstream_buffer_offset_alignment;
         self
     }
+    #[inline]
     pub fn min_bitstream_buffer_size_alignment(
         mut self,
         min_bitstream_buffer_size_alignment: DeviceSize,
@@ -46899,33 +56325,34 @@ impl<'a> VideoCapabilitiesKHRBuilder<'a> {
         self.inner.min_bitstream_buffer_size_alignment = min_bitstream_buffer_size_alignment;
         self
     }
-    pub fn video_picture_extent_granularity(
-        mut self,
-        video_picture_extent_granularity: Extent2D,
-    ) -> Self {
-        self.inner.video_picture_extent_granularity = video_picture_extent_granularity;
+    #[inline]
+    pub fn picture_access_granularity(mut self, picture_access_granularity: Extent2D) -> Self {
+        self.inner.picture_access_granularity = picture_access_granularity;
         self
     }
-    pub fn min_extent(mut self, min_extent: Extent2D) -> Self {
-        self.inner.min_extent = min_extent;
+    #[inline]
+    pub fn min_coded_extent(mut self, min_coded_extent: Extent2D) -> Self {
+        self.inner.min_coded_extent = min_coded_extent;
         self
     }
-    pub fn max_extent(mut self, max_extent: Extent2D) -> Self {
-        self.inner.max_extent = max_extent;
+    #[inline]
+    pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self {
+        self.inner.max_coded_extent = max_coded_extent;
         self
     }
-    pub fn max_reference_pictures_slots_count(
-        mut self,
-        max_reference_pictures_slots_count: u32,
-    ) -> Self {
-        self.inner.max_reference_pictures_slots_count = max_reference_pictures_slots_count;
+    #[inline]
+    pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self {
+        self.inner.max_dpb_slots = max_dpb_slots;
         self
     }
-    pub fn max_reference_pictures_active_count(
-        mut self,
-        max_reference_pictures_active_count: u32,
-    ) -> Self {
-        self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count;
+    #[inline]
+    pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self {
+        self.inner.max_active_reference_pictures = max_active_reference_pictures;
+        self
+    }
+    #[inline]
+    pub fn std_header_version(mut self, std_header_version: ExtensionProperties) -> Self {
+        self.inner.std_header_version = std_header_version;
         self
     }
     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
@@ -46935,10 +56362,10 @@ impl<'a> VideoCapabilitiesKHRBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsVideoCapabilitiesKHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*mut T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -46950,68 +56377,76 @@ impl<'a> VideoCapabilitiesKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoGetMemoryPropertiesKHR.html>"]
-pub struct VideoGetMemoryPropertiesKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionMemoryRequirementsKHR.html>"]
+pub struct VideoSessionMemoryRequirementsKHR {
     pub s_type: StructureType,
-    pub p_next: *const c_void,
+    pub p_next: *mut c_void,
     pub memory_bind_index: u32,
-    pub p_memory_requirements: *mut MemoryRequirements2,
+    pub memory_requirements: MemoryRequirements,
 }
-impl ::std::default::Default for VideoGetMemoryPropertiesKHR {
-    fn default() -> VideoGetMemoryPropertiesKHR {
-        VideoGetMemoryPropertiesKHR {
-            s_type: StructureType::VIDEO_GET_MEMORY_PROPERTIES_KHR,
-            p_next: ::std::ptr::null(),
+impl ::std::default::Default for VideoSessionMemoryRequirementsKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
             memory_bind_index: u32::default(),
-            p_memory_requirements: ::std::ptr::null_mut(),
+            memory_requirements: MemoryRequirements::default(),
         }
     }
 }
-impl VideoGetMemoryPropertiesKHR {
-    pub fn builder<'a>() -> VideoGetMemoryPropertiesKHRBuilder<'a> {
-        VideoGetMemoryPropertiesKHRBuilder {
-            inner: VideoGetMemoryPropertiesKHR::default(),
+unsafe impl TaggedStructure for VideoSessionMemoryRequirementsKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR;
+}
+impl VideoSessionMemoryRequirementsKHR {
+    pub fn builder<'a>() -> VideoSessionMemoryRequirementsKHRBuilder<'a> {
+        VideoSessionMemoryRequirementsKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoGetMemoryPropertiesKHRBuilder<'a> {
-    inner: VideoGetMemoryPropertiesKHR,
+pub struct VideoSessionMemoryRequirementsKHRBuilder<'a> {
+    inner: VideoSessionMemoryRequirementsKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for VideoGetMemoryPropertiesKHRBuilder<'a> {
-    type Target = VideoGetMemoryPropertiesKHR;
+impl<'a> ::std::ops::Deref for VideoSessionMemoryRequirementsKHRBuilder<'a> {
+    type Target = VideoSessionMemoryRequirementsKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoGetMemoryPropertiesKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoSessionMemoryRequirementsKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoGetMemoryPropertiesKHRBuilder<'a> {
+impl<'a> VideoSessionMemoryRequirementsKHRBuilder<'a> {
+    #[inline]
     pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
         self.inner.memory_bind_index = memory_bind_index;
         self
     }
-    pub fn memory_requirements(mut self, memory_requirements: &'a mut MemoryRequirements2) -> Self {
-        self.inner.p_memory_requirements = memory_requirements;
+    #[inline]
+    pub fn memory_requirements(mut self, memory_requirements: MemoryRequirements) -> Self {
+        self.inner.memory_requirements = memory_requirements;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoGetMemoryPropertiesKHR {
+    pub fn build(self) -> VideoSessionMemoryRequirementsKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoBindMemoryKHR.html>"]
-pub struct VideoBindMemoryKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBindVideoSessionMemoryInfoKHR.html>"]
+pub struct BindVideoSessionMemoryInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub memory_bind_index: u32,
@@ -47019,10 +56454,11 @@ pub struct VideoBindMemoryKHR {
     pub memory_offset: DeviceSize,
     pub memory_size: DeviceSize,
 }
-impl ::std::default::Default for VideoBindMemoryKHR {
-    fn default() -> VideoBindMemoryKHR {
-        VideoBindMemoryKHR {
-            s_type: StructureType::VIDEO_BIND_MEMORY_KHR,
+impl ::std::default::Default for BindVideoSessionMemoryInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             memory_bind_index: u32::default(),
             memory: DeviceMemory::default(),
@@ -47031,43 +56467,50 @@ impl ::std::default::Default for VideoBindMemoryKHR {
         }
     }
 }
-impl VideoBindMemoryKHR {
-    pub fn builder<'a>() -> VideoBindMemoryKHRBuilder<'a> {
-        VideoBindMemoryKHRBuilder {
-            inner: VideoBindMemoryKHR::default(),
+unsafe impl TaggedStructure for BindVideoSessionMemoryInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::BIND_VIDEO_SESSION_MEMORY_INFO_KHR;
+}
+impl BindVideoSessionMemoryInfoKHR {
+    pub fn builder<'a>() -> BindVideoSessionMemoryInfoKHRBuilder<'a> {
+        BindVideoSessionMemoryInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoBindMemoryKHRBuilder<'a> {
-    inner: VideoBindMemoryKHR,
+pub struct BindVideoSessionMemoryInfoKHRBuilder<'a> {
+    inner: BindVideoSessionMemoryInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for VideoBindMemoryKHRBuilder<'a> {
-    type Target = VideoBindMemoryKHR;
+impl<'a> ::std::ops::Deref for BindVideoSessionMemoryInfoKHRBuilder<'a> {
+    type Target = BindVideoSessionMemoryInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoBindMemoryKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for BindVideoSessionMemoryInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoBindMemoryKHRBuilder<'a> {
+impl<'a> BindVideoSessionMemoryInfoKHRBuilder<'a> {
+    #[inline]
     pub fn memory_bind_index(mut self, memory_bind_index: u32) -> Self {
         self.inner.memory_bind_index = memory_bind_index;
         self
     }
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn memory_offset(mut self, memory_offset: DeviceSize) -> Self {
         self.inner.memory_offset = memory_offset;
         self
     }
+    #[inline]
     pub fn memory_size(mut self, memory_size: DeviceSize) -> Self {
         self.inner.memory_size = memory_size;
         self
@@ -47075,14 +56518,15 @@ impl<'a> VideoBindMemoryKHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoBindMemoryKHR {
+    pub fn build(self) -> BindVideoSessionMemoryInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoPictureResourceKHR.html>"]
-pub struct VideoPictureResourceKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoPictureResourceInfoKHR.html>"]
+pub struct VideoPictureResourceInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub coded_offset: Offset2D,
@@ -47090,10 +56534,11 @@ pub struct VideoPictureResourceKHR {
     pub base_array_layer: u32,
     pub image_view_binding: ImageView,
 }
-impl ::std::default::Default for VideoPictureResourceKHR {
-    fn default() -> VideoPictureResourceKHR {
-        VideoPictureResourceKHR {
-            s_type: StructureType::VIDEO_PICTURE_RESOURCE_KHR,
+impl ::std::default::Default for VideoPictureResourceInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             coded_offset: Offset2D::default(),
             coded_extent: Extent2D::default(),
@@ -47102,43 +56547,50 @@ impl ::std::default::Default for VideoPictureResourceKHR {
         }
     }
 }
-impl VideoPictureResourceKHR {
-    pub fn builder<'a>() -> VideoPictureResourceKHRBuilder<'a> {
-        VideoPictureResourceKHRBuilder {
-            inner: VideoPictureResourceKHR::default(),
+unsafe impl TaggedStructure for VideoPictureResourceInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_PICTURE_RESOURCE_INFO_KHR;
+}
+impl VideoPictureResourceInfoKHR {
+    pub fn builder<'a>() -> VideoPictureResourceInfoKHRBuilder<'a> {
+        VideoPictureResourceInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoPictureResourceKHRBuilder<'a> {
-    inner: VideoPictureResourceKHR,
+pub struct VideoPictureResourceInfoKHRBuilder<'a> {
+    inner: VideoPictureResourceInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for VideoPictureResourceKHRBuilder<'a> {
-    type Target = VideoPictureResourceKHR;
+impl<'a> ::std::ops::Deref for VideoPictureResourceInfoKHRBuilder<'a> {
+    type Target = VideoPictureResourceInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoPictureResourceKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoPictureResourceInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoPictureResourceKHRBuilder<'a> {
+impl<'a> VideoPictureResourceInfoKHRBuilder<'a> {
+    #[inline]
     pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self {
         self.inner.coded_offset = coded_offset;
         self
     }
+    #[inline]
     pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
         self.inner.coded_extent = coded_extent;
         self
     }
+    #[inline]
     pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
         self.inner.base_array_layer = base_array_layer;
         self
     }
+    #[inline]
     pub fn image_view_binding(mut self, image_view_binding: ImageView) -> Self {
         self.inner.image_view_binding = image_view_binding;
         self
@@ -47146,60 +56598,67 @@ impl<'a> VideoPictureResourceKHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoPictureResourceKHR {
+    pub fn build(self) -> VideoPictureResourceInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoReferenceSlotKHR.html>"]
-pub struct VideoReferenceSlotKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoReferenceSlotInfoKHR.html>"]
+pub struct VideoReferenceSlotInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub slot_index: i8,
-    pub p_picture_resource: *const VideoPictureResourceKHR,
-}
-impl ::std::default::Default for VideoReferenceSlotKHR {
-    fn default() -> VideoReferenceSlotKHR {
-        VideoReferenceSlotKHR {
-            s_type: StructureType::VIDEO_REFERENCE_SLOT_KHR,
+    pub slot_index: i32,
+    pub p_picture_resource: *const VideoPictureResourceInfoKHR,
+}
+impl ::std::default::Default for VideoReferenceSlotInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            slot_index: i8::default(),
+            slot_index: i32::default(),
             p_picture_resource: ::std::ptr::null(),
         }
     }
 }
-impl VideoReferenceSlotKHR {
-    pub fn builder<'a>() -> VideoReferenceSlotKHRBuilder<'a> {
-        VideoReferenceSlotKHRBuilder {
-            inner: VideoReferenceSlotKHR::default(),
+unsafe impl TaggedStructure for VideoReferenceSlotInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_REFERENCE_SLOT_INFO_KHR;
+}
+impl VideoReferenceSlotInfoKHR {
+    pub fn builder<'a>() -> VideoReferenceSlotInfoKHRBuilder<'a> {
+        VideoReferenceSlotInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoReferenceSlotKHRBuilder<'a> {
-    inner: VideoReferenceSlotKHR,
+pub struct VideoReferenceSlotInfoKHRBuilder<'a> {
+    inner: VideoReferenceSlotInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-pub unsafe trait ExtendsVideoReferenceSlotKHR {}
-impl<'a> ::std::ops::Deref for VideoReferenceSlotKHRBuilder<'a> {
-    type Target = VideoReferenceSlotKHR;
+pub unsafe trait ExtendsVideoReferenceSlotInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoReferenceSlotInfoKHRBuilder<'a> {
+    type Target = VideoReferenceSlotInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoReferenceSlotKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoReferenceSlotInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoReferenceSlotKHRBuilder<'a> {
-    pub fn slot_index(mut self, slot_index: i8) -> Self {
+impl<'a> VideoReferenceSlotInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn slot_index(mut self, slot_index: i32) -> Self {
         self.inner.slot_index = slot_index;
         self
     }
-    pub fn picture_resource(mut self, picture_resource: &'a VideoPictureResourceKHR) -> Self {
+    #[inline]
+    pub fn picture_resource(mut self, picture_resource: &'a VideoPictureResourceInfoKHR) -> Self {
         self.inner.p_picture_resource = picture_resource;
         self
     }
@@ -47208,61 +56667,186 @@ impl<'a> VideoReferenceSlotKHRBuilder<'a> {
     #[doc = r" valid extension structs can be pushed into the chain."]
     #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
     #[doc = r" chain will look like `A -> D -> B -> C`."]
-    pub fn push_next<T: ExtendsVideoReferenceSlotKHR>(mut self, next: &'a mut T) -> Self {
+    pub fn push_next<T: ExtendsVideoReferenceSlotInfoKHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoReferenceSlotInfoKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeCapabilitiesKHR.html>"]
+pub struct VideoDecodeCapabilitiesKHR {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub flags: VideoDecodeCapabilityFlagsKHR,
+}
+impl ::std::default::Default for VideoDecodeCapabilitiesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            flags: VideoDecodeCapabilityFlagsKHR::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoDecodeCapabilitiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_CAPABILITIES_KHR;
+}
+impl VideoDecodeCapabilitiesKHR {
+    pub fn builder<'a>() -> VideoDecodeCapabilitiesKHRBuilder<'a> {
+        VideoDecodeCapabilitiesKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoDecodeCapabilitiesKHRBuilder<'a> {
+    inner: VideoDecodeCapabilitiesKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHRBuilder<'_> {}
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeCapabilitiesKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeCapabilitiesKHRBuilder<'a> {
+    type Target = VideoDecodeCapabilitiesKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoDecodeCapabilitiesKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoDecodeCapabilitiesKHRBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: VideoDecodeCapabilityFlagsKHR) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoDecodeCapabilitiesKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeUsageInfoKHR.html>"]
+pub struct VideoDecodeUsageInfoKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub video_usage_hints: VideoDecodeUsageFlagsKHR,
+}
+impl ::std::default::Default for VideoDecodeUsageInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            video_usage_hints: VideoDecodeUsageFlagsKHR::default(),
         }
+    }
+}
+unsafe impl TaggedStructure for VideoDecodeUsageInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_USAGE_INFO_KHR;
+}
+impl VideoDecodeUsageInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeUsageInfoKHRBuilder<'a> {
+        VideoDecodeUsageInfoKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoDecodeUsageInfoKHRBuilder<'a> {
+    inner: VideoDecodeUsageInfoKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHR {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHRBuilder<'_> {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeUsageInfoKHRBuilder<'a> {
+    type Target = VideoDecodeUsageInfoKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoDecodeUsageInfoKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoDecodeUsageInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn video_usage_hints(mut self, video_usage_hints: VideoDecodeUsageFlagsKHR) -> Self {
+        self.inner.video_usage_hints = video_usage_hints;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoReferenceSlotKHR {
+    pub fn build(self) -> VideoDecodeUsageInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeInfoKHR.html>"]
 pub struct VideoDecodeInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: VideoDecodeFlagsKHR,
-    pub coded_offset: Offset2D,
-    pub coded_extent: Extent2D,
     pub src_buffer: Buffer,
     pub src_buffer_offset: DeviceSize,
     pub src_buffer_range: DeviceSize,
-    pub dst_picture_resource: VideoPictureResourceKHR,
-    pub p_setup_reference_slot: *const VideoReferenceSlotKHR,
+    pub dst_picture_resource: VideoPictureResourceInfoKHR,
+    pub p_setup_reference_slot: *const VideoReferenceSlotInfoKHR,
     pub reference_slot_count: u32,
-    pub p_reference_slots: *const VideoReferenceSlotKHR,
+    pub p_reference_slots: *const VideoReferenceSlotInfoKHR,
 }
 impl ::std::default::Default for VideoDecodeInfoKHR {
-    fn default() -> VideoDecodeInfoKHR {
-        VideoDecodeInfoKHR {
-            s_type: StructureType::VIDEO_DECODE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: VideoDecodeFlagsKHR::default(),
-            coded_offset: Offset2D::default(),
-            coded_extent: Extent2D::default(),
             src_buffer: Buffer::default(),
             src_buffer_offset: DeviceSize::default(),
             src_buffer_range: DeviceSize::default(),
-            dst_picture_resource: VideoPictureResourceKHR::default(),
+            dst_picture_resource: VideoPictureResourceInfoKHR::default(),
             p_setup_reference_slot: ::std::ptr::null(),
             reference_slot_count: u32::default(),
             p_reference_slots: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoDecodeInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_INFO_KHR;
+}
 impl VideoDecodeInfoKHR {
     pub fn builder<'a>() -> VideoDecodeInfoKHRBuilder<'a> {
         VideoDecodeInfoKHRBuilder {
-            inner: VideoDecodeInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -47285,39 +56869,44 @@ impl<'a> ::std::ops::DerefMut for VideoDecodeInfoKHRBuilder<'a> {
     }
 }
 impl<'a> VideoDecodeInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: VideoDecodeFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
-    pub fn coded_offset(mut self, coded_offset: Offset2D) -> Self {
-        self.inner.coded_offset = coded_offset;
-        self
-    }
-    pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
-        self.inner.coded_extent = coded_extent;
-        self
-    }
+    #[inline]
     pub fn src_buffer(mut self, src_buffer: Buffer) -> Self {
         self.inner.src_buffer = src_buffer;
         self
     }
+    #[inline]
     pub fn src_buffer_offset(mut self, src_buffer_offset: DeviceSize) -> Self {
         self.inner.src_buffer_offset = src_buffer_offset;
         self
     }
+    #[inline]
     pub fn src_buffer_range(mut self, src_buffer_range: DeviceSize) -> Self {
         self.inner.src_buffer_range = src_buffer_range;
         self
     }
-    pub fn dst_picture_resource(mut self, dst_picture_resource: VideoPictureResourceKHR) -> Self {
+    #[inline]
+    pub fn dst_picture_resource(
+        mut self,
+        dst_picture_resource: VideoPictureResourceInfoKHR,
+    ) -> Self {
         self.inner.dst_picture_resource = dst_picture_resource;
         self
     }
-    pub fn setup_reference_slot(mut self, setup_reference_slot: &'a VideoReferenceSlotKHR) -> Self {
+    #[inline]
+    pub fn setup_reference_slot(
+        mut self,
+        setup_reference_slot: &'a VideoReferenceSlotInfoKHR,
+    ) -> Self {
         self.inner.p_setup_reference_slot = setup_reference_slot;
         self
     }
-    pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self {
+    #[inline]
+    pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self {
         self.inner.reference_slot_count = reference_slots.len() as _;
         self.inner.p_reference_slots = reference_slots.as_ptr();
         self
@@ -47329,10 +56918,10 @@ impl<'a> VideoDecodeInfoKHRBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsVideoDecodeInfoKHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -47344,332 +56933,298 @@ impl<'a> VideoDecodeInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264ProfileEXT.html>"]
-pub struct VideoDecodeH264ProfileEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264ProfileInfoKHR.html>"]
+pub struct VideoDecodeH264ProfileInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub std_profile_idc: StdVideoH264ProfileIdc,
-    pub picture_layout: VideoDecodeH264PictureLayoutFlagsEXT,
+    pub picture_layout: VideoDecodeH264PictureLayoutFlagsKHR,
 }
-impl ::std::default::Default for VideoDecodeH264ProfileEXT {
-    fn default() -> VideoDecodeH264ProfileEXT {
-        VideoDecodeH264ProfileEXT {
-            s_type: StructureType::VIDEO_DECODE_H264_PROFILE_EXT,
+impl ::std::default::Default for VideoDecodeH264ProfileInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             std_profile_idc: StdVideoH264ProfileIdc::default(),
-            picture_layout: VideoDecodeH264PictureLayoutFlagsEXT::default(),
+            picture_layout: VideoDecodeH264PictureLayoutFlagsKHR::default(),
         }
     }
 }
-impl VideoDecodeH264ProfileEXT {
-    pub fn builder<'a>() -> VideoDecodeH264ProfileEXTBuilder<'a> {
-        VideoDecodeH264ProfileEXTBuilder {
-            inner: VideoDecodeH264ProfileEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH264ProfileInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PROFILE_INFO_KHR;
+}
+impl VideoDecodeH264ProfileInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH264ProfileInfoKHRBuilder<'a> {
+        VideoDecodeH264ProfileInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH264ProfileEXTBuilder<'a> {
-    inner: VideoDecodeH264ProfileEXT,
+pub struct VideoDecodeH264ProfileInfoKHRBuilder<'a> {
+    inner: VideoDecodeH264ProfileInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXTBuilder<'_> {}
-unsafe impl ExtendsVideoProfileKHR for VideoDecodeH264ProfileEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileEXTBuilder<'a> {
-    type Target = VideoDecodeH264ProfileEXT;
+unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH264ProfileInfoKHR {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHRBuilder<'_> {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH264ProfileInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeH264ProfileInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH264ProfileInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH264ProfileEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH264ProfileInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH264ProfileEXTBuilder<'a> {
+impl<'a> VideoDecodeH264ProfileInfoKHRBuilder<'a> {
+    #[inline]
     pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self {
         self.inner.std_profile_idc = std_profile_idc;
         self
     }
-    pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsEXT) -> Self {
+    #[inline]
+    pub fn picture_layout(mut self, picture_layout: VideoDecodeH264PictureLayoutFlagsKHR) -> Self {
         self.inner.picture_layout = picture_layout;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH264ProfileEXT {
+    pub fn build(self) -> VideoDecodeH264ProfileInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264CapabilitiesEXT.html>"]
-pub struct VideoDecodeH264CapabilitiesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264CapabilitiesKHR.html>"]
+pub struct VideoDecodeH264CapabilitiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
-    pub max_level: u32,
+    pub max_level_idc: StdVideoH264LevelIdc,
     pub field_offset_granularity: Offset2D,
-    pub std_extension_version: ExtensionProperties,
 }
-impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT {
-    fn default() -> VideoDecodeH264CapabilitiesEXT {
-        VideoDecodeH264CapabilitiesEXT {
-            s_type: StructureType::VIDEO_DECODE_H264_CAPABILITIES_EXT,
+impl ::std::default::Default for VideoDecodeH264CapabilitiesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
-            max_level: u32::default(),
+            max_level_idc: StdVideoH264LevelIdc::default(),
             field_offset_granularity: Offset2D::default(),
-            std_extension_version: ExtensionProperties::default(),
         }
     }
 }
-impl VideoDecodeH264CapabilitiesEXT {
-    pub fn builder<'a>() -> VideoDecodeH264CapabilitiesEXTBuilder<'a> {
-        VideoDecodeH264CapabilitiesEXTBuilder {
-            inner: VideoDecodeH264CapabilitiesEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH264CapabilitiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_CAPABILITIES_KHR;
+}
+impl VideoDecodeH264CapabilitiesKHR {
+    pub fn builder<'a>() -> VideoDecodeH264CapabilitiesKHRBuilder<'a> {
+        VideoDecodeH264CapabilitiesKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH264CapabilitiesEXTBuilder<'a> {
-    inner: VideoDecodeH264CapabilitiesEXT,
+pub struct VideoDecodeH264CapabilitiesKHRBuilder<'a> {
+    inner: VideoDecodeH264CapabilitiesKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesEXTBuilder<'_> {}
-unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH264CapabilitiesEXTBuilder<'a> {
-    type Target = VideoDecodeH264CapabilitiesEXT;
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHRBuilder<'_> {}
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeH264CapabilitiesKHRBuilder<'a> {
+    type Target = VideoDecodeH264CapabilitiesKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH264CapabilitiesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH264CapabilitiesKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH264CapabilitiesEXTBuilder<'a> {
-    pub fn max_level(mut self, max_level: u32) -> Self {
-        self.inner.max_level = max_level;
+impl<'a> VideoDecodeH264CapabilitiesKHRBuilder<'a> {
+    #[inline]
+    pub fn max_level_idc(mut self, max_level_idc: StdVideoH264LevelIdc) -> Self {
+        self.inner.max_level_idc = max_level_idc;
         self
     }
+    #[inline]
     pub fn field_offset_granularity(mut self, field_offset_granularity: Offset2D) -> Self {
         self.inner.field_offset_granularity = field_offset_granularity;
         self
     }
-    pub fn std_extension_version(mut self, std_extension_version: ExtensionProperties) -> Self {
-        self.inner.std_extension_version = std_extension_version;
-        self
-    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH264CapabilitiesEXT {
+    pub fn build(self) -> VideoDecodeH264CapabilitiesKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264SessionCreateInfoEXT.html>"]
-pub struct VideoDecodeH264SessionCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersAddInfoKHR.html>"]
+pub struct VideoDecodeH264SessionParametersAddInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub flags: VideoDecodeH264CreateFlagsEXT,
-    pub p_std_extension_version: *const ExtensionProperties,
-}
-impl ::std::default::Default for VideoDecodeH264SessionCreateInfoEXT {
-    fn default() -> VideoDecodeH264SessionCreateInfoEXT {
-        VideoDecodeH264SessionCreateInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT,
+    pub std_sps_count: u32,
+    pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet,
+    pub std_pps_count: u32,
+    pub p_std_pp_ss: *const StdVideoH264PictureParameterSet,
+}
+impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            flags: VideoDecodeH264CreateFlagsEXT::default(),
-            p_std_extension_version: ::std::ptr::null(),
+            std_sps_count: u32::default(),
+            p_std_sp_ss: ::std::ptr::null(),
+            std_pps_count: u32::default(),
+            p_std_pp_ss: ::std::ptr::null(),
         }
     }
 }
-impl VideoDecodeH264SessionCreateInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH264SessionCreateInfoEXTBuilder<'a> {
-        VideoDecodeH264SessionCreateInfoEXTBuilder {
-            inner: VideoDecodeH264SessionCreateInfoEXT::default(),
-            marker: ::std::marker::PhantomData,
-        }
-    }
-}
-#[repr(transparent)]
-pub struct VideoDecodeH264SessionCreateInfoEXTBuilder<'a> {
-    inner: VideoDecodeH264SessionCreateInfoEXT,
-    marker: ::std::marker::PhantomData<&'a ()>,
-}
-unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoDecodeH264SessionCreateInfoEXTBuilder<'_> {}
-unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoDecodeH264SessionCreateInfoEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH264SessionCreateInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH264SessionCreateInfoEXT;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionCreateInfoEXTBuilder<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-impl<'a> VideoDecodeH264SessionCreateInfoEXTBuilder<'a> {
-    pub fn flags(mut self, flags: VideoDecodeH264CreateFlagsEXT) -> Self {
-        self.inner.flags = flags;
-        self
-    }
-    pub fn std_extension_version(mut self, std_extension_version: &'a ExtensionProperties) -> Self {
-        self.inner.p_std_extension_version = std_extension_version;
-        self
-    }
-    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
-    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
-    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH264SessionCreateInfoEXT {
-        self.inner
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264SessionParametersAddInfoEXT.html>"]
-pub struct VideoDecodeH264SessionParametersAddInfoEXT {
-    pub s_type: StructureType,
-    pub p_next: *const c_void,
-    pub sps_std_count: u32,
-    pub p_sps_std: *const StdVideoH264SequenceParameterSet,
-    pub pps_std_count: u32,
-    pub p_pps_std: *const StdVideoH264PictureParameterSet,
-}
-impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT {
-    fn default() -> VideoDecodeH264SessionParametersAddInfoEXT {
-        VideoDecodeH264SessionParametersAddInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT,
-            p_next: ::std::ptr::null(),
-            sps_std_count: u32::default(),
-            p_sps_std: ::std::ptr::null(),
-            pps_std_count: u32::default(),
-            p_pps_std: ::std::ptr::null(),
-        }
-    }
+unsafe impl TaggedStructure for VideoDecodeH264SessionParametersAddInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR;
 }
-impl VideoDecodeH264SessionParametersAddInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
-        VideoDecodeH264SessionParametersAddInfoEXTBuilder {
-            inner: VideoDecodeH264SessionParametersAddInfoEXT::default(),
+impl VideoDecodeH264SessionParametersAddInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
+        VideoDecodeH264SessionParametersAddInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
-    inner: VideoDecodeH264SessionParametersAddInfoEXT,
+pub struct VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
+    inner: VideoDecodeH264SessionParametersAddInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
-    for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'_>
+    for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'_>
 {
 }
 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
-    for VideoDecodeH264SessionParametersAddInfoEXT
+    for VideoDecodeH264SessionParametersAddInfoKHR
 {
 }
-impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH264SessionParametersAddInfoEXT;
+impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH264SessionParametersAddInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH264SessionParametersAddInfoEXTBuilder<'a> {
-    pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self {
-        self.inner.sps_std_count = sps_std.len() as _;
-        self.inner.p_sps_std = sps_std.as_ptr();
+impl<'a> VideoDecodeH264SessionParametersAddInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self {
+        self.inner.std_sps_count = std_sp_ss.len() as _;
+        self.inner.p_std_sp_ss = std_sp_ss.as_ptr();
         self
     }
-    pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self {
-        self.inner.pps_std_count = pps_std.len() as _;
-        self.inner.p_pps_std = pps_std.as_ptr();
+    #[inline]
+    pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self {
+        self.inner.std_pps_count = std_pp_ss.len() as _;
+        self.inner.p_std_pp_ss = std_pp_ss.as_ptr();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH264SessionParametersAddInfoEXT {
+    pub fn build(self) -> VideoDecodeH264SessionParametersAddInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264SessionParametersCreateInfoEXT.html>"]
-pub struct VideoDecodeH264SessionParametersCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264SessionParametersCreateInfoKHR.html>"]
+pub struct VideoDecodeH264SessionParametersCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub max_sps_std_count: u32,
-    pub max_pps_std_count: u32,
-    pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoEXT,
-}
-impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoEXT {
-    fn default() -> VideoDecodeH264SessionParametersCreateInfoEXT {
-        VideoDecodeH264SessionParametersCreateInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT,
+    pub max_std_sps_count: u32,
+    pub max_std_pps_count: u32,
+    pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoKHR,
+}
+impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            max_sps_std_count: u32::default(),
-            max_pps_std_count: u32::default(),
+            max_std_sps_count: u32::default(),
+            max_std_pps_count: u32::default(),
             p_parameters_add_info: ::std::ptr::null(),
         }
     }
 }
-impl VideoDecodeH264SessionParametersCreateInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
-        VideoDecodeH264SessionParametersCreateInfoEXTBuilder {
-            inner: VideoDecodeH264SessionParametersCreateInfoEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH264SessionParametersCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR;
+}
+impl VideoDecodeH264SessionParametersCreateInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
+        VideoDecodeH264SessionParametersCreateInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
-    inner: VideoDecodeH264SessionParametersCreateInfoEXT,
+pub struct VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
+    inner: VideoDecodeH264SessionParametersCreateInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
-    for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'_>
+    for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'_>
 {
 }
 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
-    for VideoDecodeH264SessionParametersCreateInfoEXT
+    for VideoDecodeH264SessionParametersCreateInfoKHR
 {
 }
-impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH264SessionParametersCreateInfoEXT;
+impl<'a> ::std::ops::Deref for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH264SessionParametersCreateInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
-    pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
-        self.inner.max_sps_std_count = max_sps_std_count;
+impl<'a> VideoDecodeH264SessionParametersCreateInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self {
+        self.inner.max_std_sps_count = max_std_sps_count;
         self
     }
-    pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
-        self.inner.max_pps_std_count = max_pps_std_count;
+    #[inline]
+    pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self {
+        self.inner.max_std_pps_count = max_std_pps_count;
         self
     }
+    #[inline]
     pub fn parameters_add_info(
         mut self,
-        parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoEXT,
+        parameters_add_info: &'a VideoDecodeH264SessionParametersAddInfoKHR,
     ) -> Self {
         self.inner.p_parameters_add_info = parameters_add_info;
         self
@@ -47677,133 +57232,131 @@ impl<'a> VideoDecodeH264SessionParametersCreateInfoEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH264SessionParametersCreateInfoEXT {
+    pub fn build(self) -> VideoDecodeH264SessionParametersCreateInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264PictureInfoEXT.html>"]
-pub struct VideoDecodeH264PictureInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264PictureInfoKHR.html>"]
+pub struct VideoDecodeH264PictureInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub p_std_picture_info: *const StdVideoDecodeH264PictureInfo,
-    pub slices_count: u32,
-    pub p_slices_data_offsets: *const u32,
-}
-impl ::std::default::Default for VideoDecodeH264PictureInfoEXT {
-    fn default() -> VideoDecodeH264PictureInfoEXT {
-        VideoDecodeH264PictureInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H264_PICTURE_INFO_EXT,
+    pub slice_count: u32,
+    pub p_slice_offsets: *const u32,
+}
+impl ::std::default::Default for VideoDecodeH264PictureInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_std_picture_info: ::std::ptr::null(),
-            slices_count: u32::default(),
-            p_slices_data_offsets: ::std::ptr::null(),
+            slice_count: u32::default(),
+            p_slice_offsets: ::std::ptr::null(),
         }
     }
 }
-impl VideoDecodeH264PictureInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH264PictureInfoEXTBuilder<'a> {
-        VideoDecodeH264PictureInfoEXTBuilder {
-            inner: VideoDecodeH264PictureInfoEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH264PictureInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PICTURE_INFO_KHR;
+}
+impl VideoDecodeH264PictureInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH264PictureInfoKHRBuilder<'a> {
+        VideoDecodeH264PictureInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH264PictureInfoEXTBuilder<'a> {
-    inner: VideoDecodeH264PictureInfoEXT,
+pub struct VideoDecodeH264PictureInfoKHRBuilder<'a> {
+    inner: VideoDecodeH264PictureInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXTBuilder<'_> {}
-unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXT {}
-pub unsafe trait ExtendsVideoDecodeH264PictureInfoEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH264PictureInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH264PictureInfoEXT;
+unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeH264PictureInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH264PictureInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH264PictureInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH264PictureInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH264PictureInfoEXTBuilder<'a> {
+impl<'a> VideoDecodeH264PictureInfoKHRBuilder<'a> {
+    #[inline]
     pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self {
         self.inner.p_std_picture_info = std_picture_info;
         self
     }
-    pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self {
-        self.inner.slices_count = slices_data_offsets.len() as _;
-        self.inner.p_slices_data_offsets = slices_data_offsets.as_ptr();
-        self
-    }
-    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
-    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
-    #[doc = r" valid extension structs can be pushed into the chain."]
-    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
-    #[doc = r" chain will look like `A -> D -> B -> C`."]
-    pub fn push_next<T: ExtendsVideoDecodeH264PictureInfoEXT>(mut self, next: &'a mut T) -> Self {
-        unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
-            let last_next = ptr_chain_iter(next).last().unwrap();
-            (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
-        }
+    #[inline]
+    pub fn slice_offsets(mut self, slice_offsets: &'a [u32]) -> Self {
+        self.inner.slice_count = slice_offsets.len() as _;
+        self.inner.p_slice_offsets = slice_offsets.as_ptr();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH264PictureInfoEXT {
+    pub fn build(self) -> VideoDecodeH264PictureInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264DpbSlotInfoEXT.html>"]
-pub struct VideoDecodeH264DpbSlotInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH264DpbSlotInfoKHR.html>"]
+pub struct VideoDecodeH264DpbSlotInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub p_std_reference_info: *const StdVideoDecodeH264ReferenceInfo,
 }
-impl ::std::default::Default for VideoDecodeH264DpbSlotInfoEXT {
-    fn default() -> VideoDecodeH264DpbSlotInfoEXT {
-        VideoDecodeH264DpbSlotInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT,
+impl ::std::default::Default for VideoDecodeH264DpbSlotInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_std_reference_info: ::std::ptr::null(),
         }
     }
 }
-impl VideoDecodeH264DpbSlotInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
-        VideoDecodeH264DpbSlotInfoEXTBuilder {
-            inner: VideoDecodeH264DpbSlotInfoEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH264DpbSlotInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR;
+}
+impl VideoDecodeH264DpbSlotInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
+        VideoDecodeH264DpbSlotInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
-    inner: VideoDecodeH264DpbSlotInfoEXT,
+pub struct VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
+    inner: VideoDecodeH264DpbSlotInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH264DpbSlotInfoEXTBuilder<'_> {}
-unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH264DpbSlotInfoEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH264DpbSlotInfoEXT;
+unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH264DpbSlotInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH264DpbSlotInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
+impl<'a> VideoDecodeH264DpbSlotInfoKHRBuilder<'a> {
+    #[inline]
     pub fn std_reference_info(
         mut self,
         std_reference_info: &'a StdVideoDecodeH264ReferenceInfo,
@@ -47814,109 +57367,62 @@ impl<'a> VideoDecodeH264DpbSlotInfoEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH264DpbSlotInfoEXT {
+    pub fn build(self) -> VideoDecodeH264DpbSlotInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH264MvcEXT.html>"]
-pub struct VideoDecodeH264MvcEXT {
-    pub s_type: StructureType,
-    pub p_next: *const c_void,
-    pub p_std_mvc: *const StdVideoDecodeH264Mvc,
-}
-impl ::std::default::Default for VideoDecodeH264MvcEXT {
-    fn default() -> VideoDecodeH264MvcEXT {
-        VideoDecodeH264MvcEXT {
-            s_type: StructureType::VIDEO_DECODE_H264_MVC_EXT,
-            p_next: ::std::ptr::null(),
-            p_std_mvc: ::std::ptr::null(),
-        }
-    }
-}
-impl VideoDecodeH264MvcEXT {
-    pub fn builder<'a>() -> VideoDecodeH264MvcEXTBuilder<'a> {
-        VideoDecodeH264MvcEXTBuilder {
-            inner: VideoDecodeH264MvcEXT::default(),
-            marker: ::std::marker::PhantomData,
-        }
-    }
-}
-#[repr(transparent)]
-pub struct VideoDecodeH264MvcEXTBuilder<'a> {
-    inner: VideoDecodeH264MvcEXT,
-    marker: ::std::marker::PhantomData<&'a ()>,
-}
-unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXTBuilder<'_> {}
-unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH264MvcEXTBuilder<'a> {
-    type Target = VideoDecodeH264MvcEXT;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-impl<'a> ::std::ops::DerefMut for VideoDecodeH264MvcEXTBuilder<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-impl<'a> VideoDecodeH264MvcEXTBuilder<'a> {
-    pub fn std_mvc(mut self, std_mvc: &'a StdVideoDecodeH264Mvc) -> Self {
-        self.inner.p_std_mvc = std_mvc;
-        self
-    }
-    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
-    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
-    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH264MvcEXT {
-        self.inner
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265ProfileEXT.html>"]
-pub struct VideoDecodeH265ProfileEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265ProfileInfoKHR.html>"]
+pub struct VideoDecodeH265ProfileInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub std_profile_idc: StdVideoH265ProfileIdc,
 }
-impl ::std::default::Default for VideoDecodeH265ProfileEXT {
-    fn default() -> VideoDecodeH265ProfileEXT {
-        VideoDecodeH265ProfileEXT {
-            s_type: StructureType::VIDEO_DECODE_H265_PROFILE_EXT,
+impl ::std::default::Default for VideoDecodeH265ProfileInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             std_profile_idc: StdVideoH265ProfileIdc::default(),
         }
     }
 }
-impl VideoDecodeH265ProfileEXT {
-    pub fn builder<'a>() -> VideoDecodeH265ProfileEXTBuilder<'a> {
-        VideoDecodeH265ProfileEXTBuilder {
-            inner: VideoDecodeH265ProfileEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH265ProfileInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PROFILE_INFO_KHR;
+}
+impl VideoDecodeH265ProfileInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH265ProfileInfoKHRBuilder<'a> {
+        VideoDecodeH265ProfileInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH265ProfileEXTBuilder<'a> {
-    inner: VideoDecodeH265ProfileEXT,
+pub struct VideoDecodeH265ProfileInfoKHRBuilder<'a> {
+    inner: VideoDecodeH265ProfileInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXTBuilder<'_> {}
-unsafe impl ExtendsVideoProfileKHR for VideoDecodeH265ProfileEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileEXTBuilder<'a> {
-    type Target = VideoDecodeH265ProfileEXT;
+unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeH265ProfileInfoKHR {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHRBuilder<'_> {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeH265ProfileInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeH265ProfileInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH265ProfileInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH265ProfileEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH265ProfileInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH265ProfileEXTBuilder<'a> {
+impl<'a> VideoDecodeH265ProfileInfoKHRBuilder<'a> {
+    #[inline]
     pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self {
         self.inner.std_profile_idc = std_profile_idc;
         self
@@ -47924,270 +57430,243 @@ impl<'a> VideoDecodeH265ProfileEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH265ProfileEXT {
+    pub fn build(self) -> VideoDecodeH265ProfileInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265CapabilitiesEXT.html>"]
-pub struct VideoDecodeH265CapabilitiesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265CapabilitiesKHR.html>"]
+pub struct VideoDecodeH265CapabilitiesKHR {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
-    pub max_level: u32,
-    pub std_extension_version: ExtensionProperties,
+    pub max_level_idc: StdVideoH265LevelIdc,
 }
-impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT {
-    fn default() -> VideoDecodeH265CapabilitiesEXT {
-        VideoDecodeH265CapabilitiesEXT {
-            s_type: StructureType::VIDEO_DECODE_H265_CAPABILITIES_EXT,
+impl ::std::default::Default for VideoDecodeH265CapabilitiesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
-            max_level: u32::default(),
-            std_extension_version: ExtensionProperties::default(),
+            max_level_idc: StdVideoH265LevelIdc::default(),
         }
     }
 }
-impl VideoDecodeH265CapabilitiesEXT {
-    pub fn builder<'a>() -> VideoDecodeH265CapabilitiesEXTBuilder<'a> {
-        VideoDecodeH265CapabilitiesEXTBuilder {
-            inner: VideoDecodeH265CapabilitiesEXT::default(),
-            marker: ::std::marker::PhantomData,
-        }
-    }
-}
-#[repr(transparent)]
-pub struct VideoDecodeH265CapabilitiesEXTBuilder<'a> {
-    inner: VideoDecodeH265CapabilitiesEXT,
-    marker: ::std::marker::PhantomData<&'a ()>,
+unsafe impl TaggedStructure for VideoDecodeH265CapabilitiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_CAPABILITIES_KHR;
 }
-unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesEXTBuilder<'_> {}
-unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH265CapabilitiesEXTBuilder<'a> {
-    type Target = VideoDecodeH265CapabilitiesEXT;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-impl<'a> ::std::ops::DerefMut for VideoDecodeH265CapabilitiesEXTBuilder<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-impl<'a> VideoDecodeH265CapabilitiesEXTBuilder<'a> {
-    pub fn max_level(mut self, max_level: u32) -> Self {
-        self.inner.max_level = max_level;
-        self
-    }
-    pub fn std_extension_version(mut self, std_extension_version: ExtensionProperties) -> Self {
-        self.inner.std_extension_version = std_extension_version;
-        self
-    }
-    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
-    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
-    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH265CapabilitiesEXT {
-        self.inner
-    }
-}
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265SessionCreateInfoEXT.html>"]
-pub struct VideoDecodeH265SessionCreateInfoEXT {
-    pub s_type: StructureType,
-    pub p_next: *const c_void,
-    pub flags: VideoDecodeH265CreateFlagsEXT,
-    pub p_std_extension_version: *const ExtensionProperties,
-}
-impl ::std::default::Default for VideoDecodeH265SessionCreateInfoEXT {
-    fn default() -> VideoDecodeH265SessionCreateInfoEXT {
-        VideoDecodeH265SessionCreateInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT,
-            p_next: ::std::ptr::null(),
-            flags: VideoDecodeH265CreateFlagsEXT::default(),
-            p_std_extension_version: ::std::ptr::null(),
-        }
-    }
-}
-impl VideoDecodeH265SessionCreateInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH265SessionCreateInfoEXTBuilder<'a> {
-        VideoDecodeH265SessionCreateInfoEXTBuilder {
-            inner: VideoDecodeH265SessionCreateInfoEXT::default(),
+impl VideoDecodeH265CapabilitiesKHR {
+    pub fn builder<'a>() -> VideoDecodeH265CapabilitiesKHRBuilder<'a> {
+        VideoDecodeH265CapabilitiesKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH265SessionCreateInfoEXTBuilder<'a> {
-    inner: VideoDecodeH265SessionCreateInfoEXT,
+pub struct VideoDecodeH265CapabilitiesKHRBuilder<'a> {
+    inner: VideoDecodeH265CapabilitiesKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoDecodeH265SessionCreateInfoEXTBuilder<'_> {}
-unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoDecodeH265SessionCreateInfoEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH265SessionCreateInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH265SessionCreateInfoEXT;
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHRBuilder<'_> {}
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeH265CapabilitiesKHRBuilder<'a> {
+    type Target = VideoDecodeH265CapabilitiesKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH265CapabilitiesKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH265SessionCreateInfoEXTBuilder<'a> {
-    pub fn flags(mut self, flags: VideoDecodeH265CreateFlagsEXT) -> Self {
-        self.inner.flags = flags;
-        self
-    }
-    pub fn std_extension_version(mut self, std_extension_version: &'a ExtensionProperties) -> Self {
-        self.inner.p_std_extension_version = std_extension_version;
+impl<'a> VideoDecodeH265CapabilitiesKHRBuilder<'a> {
+    #[inline]
+    pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self {
+        self.inner.max_level_idc = max_level_idc;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH265SessionCreateInfoEXT {
+    pub fn build(self) -> VideoDecodeH265CapabilitiesKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265SessionParametersAddInfoEXT.html>"]
-pub struct VideoDecodeH265SessionParametersAddInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersAddInfoKHR.html>"]
+pub struct VideoDecodeH265SessionParametersAddInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub sps_std_count: u32,
-    pub p_sps_std: *const StdVideoH265SequenceParameterSet,
-    pub pps_std_count: u32,
-    pub p_pps_std: *const StdVideoH265PictureParameterSet,
-}
-impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT {
-    fn default() -> VideoDecodeH265SessionParametersAddInfoEXT {
-        VideoDecodeH265SessionParametersAddInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT,
+    pub std_vps_count: u32,
+    pub p_std_vp_ss: *const StdVideoH265VideoParameterSet,
+    pub std_sps_count: u32,
+    pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet,
+    pub std_pps_count: u32,
+    pub p_std_pp_ss: *const StdVideoH265PictureParameterSet,
+}
+impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            sps_std_count: u32::default(),
-            p_sps_std: ::std::ptr::null(),
-            pps_std_count: u32::default(),
-            p_pps_std: ::std::ptr::null(),
+            std_vps_count: u32::default(),
+            p_std_vp_ss: ::std::ptr::null(),
+            std_sps_count: u32::default(),
+            p_std_sp_ss: ::std::ptr::null(),
+            std_pps_count: u32::default(),
+            p_std_pp_ss: ::std::ptr::null(),
         }
     }
 }
-impl VideoDecodeH265SessionParametersAddInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
-        VideoDecodeH265SessionParametersAddInfoEXTBuilder {
-            inner: VideoDecodeH265SessionParametersAddInfoEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH265SessionParametersAddInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR;
+}
+impl VideoDecodeH265SessionParametersAddInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
+        VideoDecodeH265SessionParametersAddInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
-    inner: VideoDecodeH265SessionParametersAddInfoEXT,
+pub struct VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
+    inner: VideoDecodeH265SessionParametersAddInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
-    for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'_>
+    for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'_>
 {
 }
 unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
-    for VideoDecodeH265SessionParametersAddInfoEXT
+    for VideoDecodeH265SessionParametersAddInfoKHR
 {
 }
-impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH265SessionParametersAddInfoEXT;
+impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH265SessionParametersAddInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH265SessionParametersAddInfoEXTBuilder<'a> {
-    pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self {
-        self.inner.sps_std_count = sps_std.len() as _;
-        self.inner.p_sps_std = sps_std.as_ptr();
+impl<'a> VideoDecodeH265SessionParametersAddInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self {
+        self.inner.std_vps_count = std_vp_ss.len() as _;
+        self.inner.p_std_vp_ss = std_vp_ss.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self {
+        self.inner.std_sps_count = std_sp_ss.len() as _;
+        self.inner.p_std_sp_ss = std_sp_ss.as_ptr();
         self
     }
-    pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self {
-        self.inner.pps_std_count = pps_std.len() as _;
-        self.inner.p_pps_std = pps_std.as_ptr();
+    #[inline]
+    pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self {
+        self.inner.std_pps_count = std_pp_ss.len() as _;
+        self.inner.p_std_pp_ss = std_pp_ss.as_ptr();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH265SessionParametersAddInfoEXT {
+    pub fn build(self) -> VideoDecodeH265SessionParametersAddInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265SessionParametersCreateInfoEXT.html>"]
-pub struct VideoDecodeH265SessionParametersCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265SessionParametersCreateInfoKHR.html>"]
+pub struct VideoDecodeH265SessionParametersCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub max_sps_std_count: u32,
-    pub max_pps_std_count: u32,
-    pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoEXT,
-}
-impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT {
-    fn default() -> VideoDecodeH265SessionParametersCreateInfoEXT {
-        VideoDecodeH265SessionParametersCreateInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT,
+    pub max_std_vps_count: u32,
+    pub max_std_sps_count: u32,
+    pub max_std_pps_count: u32,
+    pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoKHR,
+}
+impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            max_sps_std_count: u32::default(),
-            max_pps_std_count: u32::default(),
+            max_std_vps_count: u32::default(),
+            max_std_sps_count: u32::default(),
+            max_std_pps_count: u32::default(),
             p_parameters_add_info: ::std::ptr::null(),
         }
     }
 }
-impl VideoDecodeH265SessionParametersCreateInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
-        VideoDecodeH265SessionParametersCreateInfoEXTBuilder {
-            inner: VideoDecodeH265SessionParametersCreateInfoEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH265SessionParametersCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR;
+}
+impl VideoDecodeH265SessionParametersCreateInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
+        VideoDecodeH265SessionParametersCreateInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
-    inner: VideoDecodeH265SessionParametersCreateInfoEXT,
+pub struct VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
+    inner: VideoDecodeH265SessionParametersCreateInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
-    for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'_>
+    for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'_>
 {
 }
 unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
-    for VideoDecodeH265SessionParametersCreateInfoEXT
+    for VideoDecodeH265SessionParametersCreateInfoKHR
 {
 }
-impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH265SessionParametersCreateInfoEXT;
+impl<'a> ::std::ops::Deref for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH265SessionParametersCreateInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
-    pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
-        self.inner.max_sps_std_count = max_sps_std_count;
+impl<'a> VideoDecodeH265SessionParametersCreateInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self {
+        self.inner.max_std_vps_count = max_std_vps_count;
+        self
+    }
+    #[inline]
+    pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self {
+        self.inner.max_std_sps_count = max_std_sps_count;
         self
     }
-    pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
-        self.inner.max_pps_std_count = max_pps_std_count;
+    #[inline]
+    pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self {
+        self.inner.max_std_pps_count = max_std_pps_count;
         self
     }
+    #[inline]
     pub fn parameters_add_info(
         mut self,
-        parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoEXT,
+        parameters_add_info: &'a VideoDecodeH265SessionParametersAddInfoKHR,
     ) -> Self {
         self.inner.p_parameters_add_info = parameters_add_info;
         self
@@ -48195,121 +57674,131 @@ impl<'a> VideoDecodeH265SessionParametersCreateInfoEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH265SessionParametersCreateInfoEXT {
+    pub fn build(self) -> VideoDecodeH265SessionParametersCreateInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265PictureInfoEXT.html>"]
-pub struct VideoDecodeH265PictureInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265PictureInfoKHR.html>"]
+pub struct VideoDecodeH265PictureInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub p_std_picture_info: *mut StdVideoDecodeH265PictureInfo,
-    pub slices_count: u32,
-    pub p_slices_data_offsets: *const u32,
-}
-impl ::std::default::Default for VideoDecodeH265PictureInfoEXT {
-    fn default() -> VideoDecodeH265PictureInfoEXT {
-        VideoDecodeH265PictureInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H265_PICTURE_INFO_EXT,
+    pub p_std_picture_info: *const StdVideoDecodeH265PictureInfo,
+    pub slice_segment_count: u32,
+    pub p_slice_segment_offsets: *const u32,
+}
+impl ::std::default::Default for VideoDecodeH265PictureInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            p_std_picture_info: ::std::ptr::null_mut(),
-            slices_count: u32::default(),
-            p_slices_data_offsets: ::std::ptr::null(),
+            p_std_picture_info: ::std::ptr::null(),
+            slice_segment_count: u32::default(),
+            p_slice_segment_offsets: ::std::ptr::null(),
         }
     }
 }
-impl VideoDecodeH265PictureInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH265PictureInfoEXTBuilder<'a> {
-        VideoDecodeH265PictureInfoEXTBuilder {
-            inner: VideoDecodeH265PictureInfoEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH265PictureInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_PICTURE_INFO_KHR;
+}
+impl VideoDecodeH265PictureInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH265PictureInfoKHRBuilder<'a> {
+        VideoDecodeH265PictureInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH265PictureInfoEXTBuilder<'a> {
-    inner: VideoDecodeH265PictureInfoEXT,
+pub struct VideoDecodeH265PictureInfoKHRBuilder<'a> {
+    inner: VideoDecodeH265PictureInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXTBuilder<'_> {}
-unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH265PictureInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH265PictureInfoEXT;
+unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH265PictureInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeH265PictureInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH265PictureInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH265PictureInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH265PictureInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH265PictureInfoEXTBuilder<'a> {
-    pub fn std_picture_info(
-        mut self,
-        std_picture_info: &'a mut StdVideoDecodeH265PictureInfo,
-    ) -> Self {
+impl<'a> VideoDecodeH265PictureInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH265PictureInfo) -> Self {
         self.inner.p_std_picture_info = std_picture_info;
         self
     }
-    pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self {
-        self.inner.slices_count = slices_data_offsets.len() as _;
-        self.inner.p_slices_data_offsets = slices_data_offsets.as_ptr();
+    #[inline]
+    pub fn slice_segment_offsets(mut self, slice_segment_offsets: &'a [u32]) -> Self {
+        self.inner.slice_segment_count = slice_segment_offsets.len() as _;
+        self.inner.p_slice_segment_offsets = slice_segment_offsets.as_ptr();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH265PictureInfoEXT {
+    pub fn build(self) -> VideoDecodeH265PictureInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoDecodeH265DpbSlotInfoEXT.html>"]
-pub struct VideoDecodeH265DpbSlotInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoDecodeH265DpbSlotInfoKHR.html>"]
+pub struct VideoDecodeH265DpbSlotInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub p_std_reference_info: *const StdVideoDecodeH265ReferenceInfo,
 }
-impl ::std::default::Default for VideoDecodeH265DpbSlotInfoEXT {
-    fn default() -> VideoDecodeH265DpbSlotInfoEXT {
-        VideoDecodeH265DpbSlotInfoEXT {
-            s_type: StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT,
+impl ::std::default::Default for VideoDecodeH265DpbSlotInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             p_std_reference_info: ::std::ptr::null(),
         }
     }
 }
-impl VideoDecodeH265DpbSlotInfoEXT {
-    pub fn builder<'a>() -> VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
-        VideoDecodeH265DpbSlotInfoEXTBuilder {
-            inner: VideoDecodeH265DpbSlotInfoEXT::default(),
+unsafe impl TaggedStructure for VideoDecodeH265DpbSlotInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR;
+}
+impl VideoDecodeH265DpbSlotInfoKHR {
+    pub fn builder<'a>() -> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
+        VideoDecodeH265DpbSlotInfoKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
-    inner: VideoDecodeH265DpbSlotInfoEXT,
+pub struct VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
+    inner: VideoDecodeH265DpbSlotInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH265DpbSlotInfoEXTBuilder<'_> {}
-unsafe impl ExtendsVideoReferenceSlotKHR for VideoDecodeH265DpbSlotInfoEXT {}
-impl<'a> ::std::ops::Deref for VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
-    type Target = VideoDecodeH265DpbSlotInfoEXT;
+unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoDecodeH265DpbSlotInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
+    type Target = VideoDecodeH265DpbSlotInfoKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
+impl<'a> VideoDecodeH265DpbSlotInfoKHRBuilder<'a> {
+    #[inline]
     pub fn std_reference_info(
         mut self,
         std_reference_info: &'a StdVideoDecodeH265ReferenceInfo,
@@ -48320,45 +57809,52 @@ impl<'a> VideoDecodeH265DpbSlotInfoEXTBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoDecodeH265DpbSlotInfoEXT {
+    pub fn build(self) -> VideoDecodeH265DpbSlotInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionCreateInfoKHR.html>"]
 pub struct VideoSessionCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub queue_family_index: u32,
     pub flags: VideoSessionCreateFlagsKHR,
-    pub p_video_profile: *const VideoProfileKHR,
+    pub p_video_profile: *const VideoProfileInfoKHR,
     pub picture_format: Format,
     pub max_coded_extent: Extent2D,
-    pub reference_pictures_format: Format,
-    pub max_reference_pictures_slots_count: u32,
-    pub max_reference_pictures_active_count: u32,
+    pub reference_picture_format: Format,
+    pub max_dpb_slots: u32,
+    pub max_active_reference_pictures: u32,
+    pub p_std_header_version: *const ExtensionProperties,
 }
 impl ::std::default::Default for VideoSessionCreateInfoKHR {
-    fn default() -> VideoSessionCreateInfoKHR {
-        VideoSessionCreateInfoKHR {
-            s_type: StructureType::VIDEO_SESSION_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             queue_family_index: u32::default(),
             flags: VideoSessionCreateFlagsKHR::default(),
             p_video_profile: ::std::ptr::null(),
             picture_format: Format::default(),
             max_coded_extent: Extent2D::default(),
-            reference_pictures_format: Format::default(),
-            max_reference_pictures_slots_count: u32::default(),
-            max_reference_pictures_active_count: u32::default(),
+            reference_picture_format: Format::default(),
+            max_dpb_slots: u32::default(),
+            max_active_reference_pictures: u32::default(),
+            p_std_header_version: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoSessionCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_CREATE_INFO_KHR;
+}
 impl VideoSessionCreateInfoKHR {
     pub fn builder<'a>() -> VideoSessionCreateInfoKHRBuilder<'a> {
         VideoSessionCreateInfoKHRBuilder {
-            inner: VideoSessionCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -48368,7 +57864,6 @@ pub struct VideoSessionCreateInfoKHRBuilder<'a> {
     inner: VideoSessionCreateInfoKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-pub unsafe trait ExtendsVideoSessionCreateInfoKHR {}
 impl<'a> ::std::ops::Deref for VideoSessionCreateInfoKHRBuilder<'a> {
     type Target = VideoSessionCreateInfoKHR;
     fn deref(&self) -> &Self::Target {
@@ -48381,56 +57876,49 @@ impl<'a> ::std::ops::DerefMut for VideoSessionCreateInfoKHRBuilder<'a> {
     }
 }
 impl<'a> VideoSessionCreateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
         self.inner.queue_family_index = queue_family_index;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: VideoSessionCreateFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
-    pub fn video_profile(mut self, video_profile: &'a VideoProfileKHR) -> Self {
+    #[inline]
+    pub fn video_profile(mut self, video_profile: &'a VideoProfileInfoKHR) -> Self {
         self.inner.p_video_profile = video_profile;
         self
     }
+    #[inline]
     pub fn picture_format(mut self, picture_format: Format) -> Self {
         self.inner.picture_format = picture_format;
         self
     }
+    #[inline]
     pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self {
         self.inner.max_coded_extent = max_coded_extent;
         self
     }
-    pub fn reference_pictures_format(mut self, reference_pictures_format: Format) -> Self {
-        self.inner.reference_pictures_format = reference_pictures_format;
+    #[inline]
+    pub fn reference_picture_format(mut self, reference_picture_format: Format) -> Self {
+        self.inner.reference_picture_format = reference_picture_format;
         self
     }
-    pub fn max_reference_pictures_slots_count(
-        mut self,
-        max_reference_pictures_slots_count: u32,
-    ) -> Self {
-        self.inner.max_reference_pictures_slots_count = max_reference_pictures_slots_count;
+    #[inline]
+    pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self {
+        self.inner.max_dpb_slots = max_dpb_slots;
         self
     }
-    pub fn max_reference_pictures_active_count(
-        mut self,
-        max_reference_pictures_active_count: u32,
-    ) -> Self {
-        self.inner.max_reference_pictures_active_count = max_reference_pictures_active_count;
+    #[inline]
+    pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self {
+        self.inner.max_active_reference_pictures = max_active_reference_pictures;
         self
     }
-    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
-    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
-    #[doc = r" valid extension structs can be pushed into the chain."]
-    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
-    #[doc = r" chain will look like `A -> D -> B -> C`."]
-    pub fn push_next<T: ExtendsVideoSessionCreateInfoKHR>(mut self, next: &'a mut T) -> Self {
-        unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
-            let last_next = ptr_chain_iter(next).last().unwrap();
-            (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
-        }
+    #[inline]
+    pub fn std_header_version(mut self, std_header_version: &'a ExtensionProperties) -> Self {
+        self.inner.p_std_header_version = std_header_version;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -48441,28 +57929,35 @@ impl<'a> VideoSessionCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionParametersCreateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersCreateInfoKHR.html>"]
 pub struct VideoSessionParametersCreateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
+    pub flags: VideoSessionParametersCreateFlagsKHR,
     pub video_session_parameters_template: VideoSessionParametersKHR,
     pub video_session: VideoSessionKHR,
 }
 impl ::std::default::Default for VideoSessionParametersCreateInfoKHR {
-    fn default() -> VideoSessionParametersCreateInfoKHR {
-        VideoSessionParametersCreateInfoKHR {
-            s_type: StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
+            flags: VideoSessionParametersCreateFlagsKHR::default(),
             video_session_parameters_template: VideoSessionParametersKHR::default(),
             video_session: VideoSessionKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoSessionParametersCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR;
+}
 impl VideoSessionParametersCreateInfoKHR {
     pub fn builder<'a>() -> VideoSessionParametersCreateInfoKHRBuilder<'a> {
         VideoSessionParametersCreateInfoKHRBuilder {
-            inner: VideoSessionParametersCreateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -48485,6 +57980,12 @@ impl<'a> ::std::ops::DerefMut for VideoSessionParametersCreateInfoKHRBuilder<'a>
     }
 }
 impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: VideoSessionParametersCreateFlagsKHR) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
     pub fn video_session_parameters_template(
         mut self,
         video_session_parameters_template: VideoSessionParametersKHR,
@@ -48492,6 +57993,7 @@ impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> {
         self.inner.video_session_parameters_template = video_session_parameters_template;
         self
     }
+    #[inline]
     pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self {
         self.inner.video_session = video_session;
         self
@@ -48506,10 +58008,10 @@ impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -48521,26 +58023,31 @@ impl<'a> VideoSessionParametersCreateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoSessionParametersUpdateInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoSessionParametersUpdateInfoKHR.html>"]
 pub struct VideoSessionParametersUpdateInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub update_sequence_count: u32,
 }
 impl ::std::default::Default for VideoSessionParametersUpdateInfoKHR {
-    fn default() -> VideoSessionParametersUpdateInfoKHR {
-        VideoSessionParametersUpdateInfoKHR {
-            s_type: StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             update_sequence_count: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoSessionParametersUpdateInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR;
+}
 impl VideoSessionParametersUpdateInfoKHR {
     pub fn builder<'a>() -> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
         VideoSessionParametersUpdateInfoKHRBuilder {
-            inner: VideoSessionParametersUpdateInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -48563,6 +58070,7 @@ impl<'a> ::std::ops::DerefMut for VideoSessionParametersUpdateInfoKHRBuilder<'a>
     }
 }
 impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
+    #[inline]
     pub fn update_sequence_count(mut self, update_sequence_count: u32) -> Self {
         self.inner.update_sequence_count = update_sequence_count;
         self
@@ -48577,10 +58085,10 @@ impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
         next: &'a mut T,
     ) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -48592,25 +58100,25 @@ impl<'a> VideoSessionParametersUpdateInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoBeginCodingInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoBeginCodingInfoKHR.html>"]
 pub struct VideoBeginCodingInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: VideoBeginCodingFlagsKHR,
-    pub codec_quality_preset: VideoCodingQualityPresetFlagsKHR,
     pub video_session: VideoSessionKHR,
     pub video_session_parameters: VideoSessionParametersKHR,
     pub reference_slot_count: u32,
-    pub p_reference_slots: *const VideoReferenceSlotKHR,
+    pub p_reference_slots: *const VideoReferenceSlotInfoKHR,
 }
 impl ::std::default::Default for VideoBeginCodingInfoKHR {
-    fn default() -> VideoBeginCodingInfoKHR {
-        VideoBeginCodingInfoKHR {
-            s_type: StructureType::VIDEO_BEGIN_CODING_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: VideoBeginCodingFlagsKHR::default(),
-            codec_quality_preset: VideoCodingQualityPresetFlagsKHR::default(),
             video_session: VideoSessionKHR::default(),
             video_session_parameters: VideoSessionParametersKHR::default(),
             reference_slot_count: u32::default(),
@@ -48618,10 +58126,13 @@ impl ::std::default::Default for VideoBeginCodingInfoKHR {
         }
     }
 }
+unsafe impl TaggedStructure for VideoBeginCodingInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_BEGIN_CODING_INFO_KHR;
+}
 impl VideoBeginCodingInfoKHR {
     pub fn builder<'a>() -> VideoBeginCodingInfoKHRBuilder<'a> {
         VideoBeginCodingInfoKHRBuilder {
-            inner: VideoBeginCodingInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -48643,21 +58154,17 @@ impl<'a> ::std::ops::DerefMut for VideoBeginCodingInfoKHRBuilder<'a> {
     }
 }
 impl<'a> VideoBeginCodingInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: VideoBeginCodingFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
-    pub fn codec_quality_preset(
-        mut self,
-        codec_quality_preset: VideoCodingQualityPresetFlagsKHR,
-    ) -> Self {
-        self.inner.codec_quality_preset = codec_quality_preset;
-        self
-    }
+    #[inline]
     pub fn video_session(mut self, video_session: VideoSessionKHR) -> Self {
         self.inner.video_session = video_session;
         self
     }
+    #[inline]
     pub fn video_session_parameters(
         mut self,
         video_session_parameters: VideoSessionParametersKHR,
@@ -48665,7 +58172,8 @@ impl<'a> VideoBeginCodingInfoKHRBuilder<'a> {
         self.inner.video_session_parameters = video_session_parameters;
         self
     }
-    pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self {
+    #[inline]
+    pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self {
         self.inner.reference_slot_count = reference_slots.len() as _;
         self.inner.p_reference_slots = reference_slots.as_ptr();
         self
@@ -48678,26 +58186,31 @@ impl<'a> VideoBeginCodingInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEndCodingInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEndCodingInfoKHR.html>"]
 pub struct VideoEndCodingInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: VideoEndCodingFlagsKHR,
 }
 impl ::std::default::Default for VideoEndCodingInfoKHR {
-    fn default() -> VideoEndCodingInfoKHR {
-        VideoEndCodingInfoKHR {
-            s_type: StructureType::VIDEO_END_CODING_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: VideoEndCodingFlagsKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoEndCodingInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_END_CODING_INFO_KHR;
+}
 impl VideoEndCodingInfoKHR {
     pub fn builder<'a>() -> VideoEndCodingInfoKHRBuilder<'a> {
         VideoEndCodingInfoKHRBuilder {
-            inner: VideoEndCodingInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -48719,6 +58232,7 @@ impl<'a> ::std::ops::DerefMut for VideoEndCodingInfoKHRBuilder<'a> {
     }
 }
 impl<'a> VideoEndCodingInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: VideoEndCodingFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
@@ -48731,26 +58245,31 @@ impl<'a> VideoEndCodingInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoCodingControlInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodingControlInfoKHR.html>"]
 pub struct VideoCodingControlInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: VideoCodingControlFlagsKHR,
 }
 impl ::std::default::Default for VideoCodingControlInfoKHR {
-    fn default() -> VideoCodingControlInfoKHR {
-        VideoCodingControlInfoKHR {
-            s_type: StructureType::VIDEO_CODING_CONTROL_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: VideoCodingControlFlagsKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoCodingControlInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_CODING_CONTROL_INFO_KHR;
+}
 impl VideoCodingControlInfoKHR {
     pub fn builder<'a>() -> VideoCodingControlInfoKHRBuilder<'a> {
         VideoCodingControlInfoKHRBuilder {
-            inner: VideoCodingControlInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -48773,6 +58292,7 @@ impl<'a> ::std::ops::DerefMut for VideoCodingControlInfoKHRBuilder<'a> {
     }
 }
 impl<'a> VideoCodingControlInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: VideoCodingControlFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
@@ -48784,10 +58304,10 @@ impl<'a> VideoCodingControlInfoKHRBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsVideoCodingControlInfoKHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -48799,44 +58319,126 @@ impl<'a> VideoCodingControlInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeUsageInfoKHR.html>"]
+pub struct VideoEncodeUsageInfoKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub video_usage_hints: VideoEncodeUsageFlagsKHR,
+    pub video_content_hints: VideoEncodeContentFlagsKHR,
+    pub tuning_mode: VideoEncodeTuningModeKHR,
+}
+impl ::std::default::Default for VideoEncodeUsageInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            video_usage_hints: VideoEncodeUsageFlagsKHR::default(),
+            video_content_hints: VideoEncodeContentFlagsKHR::default(),
+            tuning_mode: VideoEncodeTuningModeKHR::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeUsageInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_USAGE_INFO_KHR;
+}
+impl VideoEncodeUsageInfoKHR {
+    pub fn builder<'a>() -> VideoEncodeUsageInfoKHRBuilder<'a> {
+        VideoEncodeUsageInfoKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeUsageInfoKHRBuilder<'a> {
+    inner: VideoEncodeUsageInfoKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHR {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHRBuilder<'_> {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoEncodeUsageInfoKHRBuilder<'a> {
+    type Target = VideoEncodeUsageInfoKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeUsageInfoKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeUsageInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn video_usage_hints(mut self, video_usage_hints: VideoEncodeUsageFlagsKHR) -> Self {
+        self.inner.video_usage_hints = video_usage_hints;
+        self
+    }
+    #[inline]
+    pub fn video_content_hints(mut self, video_content_hints: VideoEncodeContentFlagsKHR) -> Self {
+        self.inner.video_content_hints = video_content_hints;
+        self
+    }
+    #[inline]
+    pub fn tuning_mode(mut self, tuning_mode: VideoEncodeTuningModeKHR) -> Self {
+        self.inner.tuning_mode = tuning_mode;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeUsageInfoKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeInfoKHR.html>"]
 pub struct VideoEncodeInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: VideoEncodeFlagsKHR,
     pub quality_level: u32,
-    pub coded_extent: Extent2D,
-    pub dst_bitstream_buffer: Buffer,
-    pub dst_bitstream_buffer_offset: DeviceSize,
-    pub dst_bitstream_buffer_max_range: DeviceSize,
-    pub src_picture_resource: VideoPictureResourceKHR,
-    pub p_setup_reference_slot: *const VideoReferenceSlotKHR,
+    pub dst_buffer: Buffer,
+    pub dst_buffer_offset: DeviceSize,
+    pub dst_buffer_range: DeviceSize,
+    pub src_picture_resource: VideoPictureResourceInfoKHR,
+    pub p_setup_reference_slot: *const VideoReferenceSlotInfoKHR,
     pub reference_slot_count: u32,
-    pub p_reference_slots: *const VideoReferenceSlotKHR,
+    pub p_reference_slots: *const VideoReferenceSlotInfoKHR,
+    pub preceding_externally_encoded_bytes: u32,
 }
 impl ::std::default::Default for VideoEncodeInfoKHR {
-    fn default() -> VideoEncodeInfoKHR {
-        VideoEncodeInfoKHR {
-            s_type: StructureType::VIDEO_ENCODE_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: VideoEncodeFlagsKHR::default(),
             quality_level: u32::default(),
-            coded_extent: Extent2D::default(),
-            dst_bitstream_buffer: Buffer::default(),
-            dst_bitstream_buffer_offset: DeviceSize::default(),
-            dst_bitstream_buffer_max_range: DeviceSize::default(),
-            src_picture_resource: VideoPictureResourceKHR::default(),
+            dst_buffer: Buffer::default(),
+            dst_buffer_offset: DeviceSize::default(),
+            dst_buffer_range: DeviceSize::default(),
+            src_picture_resource: VideoPictureResourceInfoKHR::default(),
             p_setup_reference_slot: ::std::ptr::null(),
             reference_slot_count: u32::default(),
             p_reference_slots: ::std::ptr::null(),
+            preceding_externally_encoded_bytes: u32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoEncodeInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_INFO_KHR;
+}
 impl VideoEncodeInfoKHR {
     pub fn builder<'a>() -> VideoEncodeInfoKHRBuilder<'a> {
         VideoEncodeInfoKHRBuilder {
-            inner: VideoEncodeInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -48859,46 +58461,61 @@ impl<'a> ::std::ops::DerefMut for VideoEncodeInfoKHRBuilder<'a> {
     }
 }
 impl<'a> VideoEncodeInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: VideoEncodeFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn quality_level(mut self, quality_level: u32) -> Self {
         self.inner.quality_level = quality_level;
         self
     }
-    pub fn coded_extent(mut self, coded_extent: Extent2D) -> Self {
-        self.inner.coded_extent = coded_extent;
+    #[inline]
+    pub fn dst_buffer(mut self, dst_buffer: Buffer) -> Self {
+        self.inner.dst_buffer = dst_buffer;
         self
     }
-    pub fn dst_bitstream_buffer(mut self, dst_bitstream_buffer: Buffer) -> Self {
-        self.inner.dst_bitstream_buffer = dst_bitstream_buffer;
+    #[inline]
+    pub fn dst_buffer_offset(mut self, dst_buffer_offset: DeviceSize) -> Self {
+        self.inner.dst_buffer_offset = dst_buffer_offset;
         self
     }
-    pub fn dst_bitstream_buffer_offset(mut self, dst_bitstream_buffer_offset: DeviceSize) -> Self {
-        self.inner.dst_bitstream_buffer_offset = dst_bitstream_buffer_offset;
+    #[inline]
+    pub fn dst_buffer_range(mut self, dst_buffer_range: DeviceSize) -> Self {
+        self.inner.dst_buffer_range = dst_buffer_range;
         self
     }
-    pub fn dst_bitstream_buffer_max_range(
+    #[inline]
+    pub fn src_picture_resource(
         mut self,
-        dst_bitstream_buffer_max_range: DeviceSize,
+        src_picture_resource: VideoPictureResourceInfoKHR,
     ) -> Self {
-        self.inner.dst_bitstream_buffer_max_range = dst_bitstream_buffer_max_range;
-        self
-    }
-    pub fn src_picture_resource(mut self, src_picture_resource: VideoPictureResourceKHR) -> Self {
         self.inner.src_picture_resource = src_picture_resource;
         self
     }
-    pub fn setup_reference_slot(mut self, setup_reference_slot: &'a VideoReferenceSlotKHR) -> Self {
+    #[inline]
+    pub fn setup_reference_slot(
+        mut self,
+        setup_reference_slot: &'a VideoReferenceSlotInfoKHR,
+    ) -> Self {
         self.inner.p_setup_reference_slot = setup_reference_slot;
         self
     }
-    pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotKHR]) -> Self {
+    #[inline]
+    pub fn reference_slots(mut self, reference_slots: &'a [VideoReferenceSlotInfoKHR]) -> Self {
         self.inner.reference_slot_count = reference_slots.len() as _;
         self.inner.p_reference_slots = reference_slots.as_ptr();
         self
     }
+    #[inline]
+    pub fn preceding_externally_encoded_bytes(
+        mut self,
+        preceding_externally_encoded_bytes: u32,
+    ) -> Self {
+        self.inner.preceding_externally_encoded_bytes = preceding_externally_encoded_bytes;
+        self
+    }
     #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
     #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
     #[doc = r" valid extension structs can be pushed into the chain."]
@@ -48906,10 +58523,10 @@ impl<'a> VideoEncodeInfoKHRBuilder<'a> {
     #[doc = r" chain will look like `A -> D -> B -> C`."]
     pub fn push_next<T: ExtendsVideoEncodeInfoKHR>(mut self, next: &'a mut T) -> Self {
         unsafe {
-            let next_ptr = next as *mut T as *mut BaseOutStructure;
+            let next_ptr = <*const T>::cast(next);
             let last_next = ptr_chain_iter(next).last().unwrap();
             (*last_next).p_next = self.inner.p_next as _;
-            self.inner.p_next = next_ptr as _;
+            self.inner.p_next = next_ptr;
         }
         self
     }
@@ -48921,38 +58538,102 @@ impl<'a> VideoEncodeInfoKHRBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeRateControlInfoKHR.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.html>"]
+pub struct QueryPoolVideoEncodeFeedbackCreateInfoKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
+}
+impl ::std::default::Default for QueryPoolVideoEncodeFeedbackCreateInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            encode_feedback_flags: VideoEncodeFeedbackFlagsKHR::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for QueryPoolVideoEncodeFeedbackCreateInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR;
+}
+impl QueryPoolVideoEncodeFeedbackCreateInfoKHR {
+    pub fn builder<'a>() -> QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
+        QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
+    inner: QueryPoolVideoEncodeFeedbackCreateInfoKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'_> {}
+unsafe impl ExtendsQueryPoolCreateInfo for QueryPoolVideoEncodeFeedbackCreateInfoKHR {}
+impl<'a> ::std::ops::Deref for QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
+    type Target = QueryPoolVideoEncodeFeedbackCreateInfoKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> QueryPoolVideoEncodeFeedbackCreateInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn encode_feedback_flags(
+        mut self,
+        encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
+    ) -> Self {
+        self.inner.encode_feedback_flags = encode_feedback_flags;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> QueryPoolVideoEncodeFeedbackCreateInfoKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlInfoKHR.html>"]
 pub struct VideoEncodeRateControlInfoKHR {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub flags: VideoEncodeRateControlFlagsKHR,
     pub rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
-    pub average_bitrate: u32,
-    pub peak_to_average_bitrate_ratio: u16,
-    pub frame_rate_numerator: u16,
-    pub frame_rate_denominator: u16,
-    pub virtual_buffer_size_in_ms: u32,
+    pub layer_count: u32,
+    pub p_layers: *const VideoEncodeRateControlLayerInfoKHR,
 }
 impl ::std::default::Default for VideoEncodeRateControlInfoKHR {
-    fn default() -> VideoEncodeRateControlInfoKHR {
-        VideoEncodeRateControlInfoKHR {
-            s_type: StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             flags: VideoEncodeRateControlFlagsKHR::default(),
             rate_control_mode: VideoEncodeRateControlModeFlagsKHR::default(),
-            average_bitrate: u32::default(),
-            peak_to_average_bitrate_ratio: u16::default(),
-            frame_rate_numerator: u16::default(),
-            frame_rate_denominator: u16::default(),
-            virtual_buffer_size_in_ms: u32::default(),
+            layer_count: u32::default(),
+            p_layers: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoEncodeRateControlInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_INFO_KHR;
+}
 impl VideoEncodeRateControlInfoKHR {
     pub fn builder<'a>() -> VideoEncodeRateControlInfoKHRBuilder<'a> {
         VideoEncodeRateControlInfoKHRBuilder {
-            inner: VideoEncodeRateControlInfoKHR::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -48976,10 +58657,12 @@ impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlInfoKHRBuilder<'a> {
     }
 }
 impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> {
+    #[inline]
     pub fn flags(mut self, flags: VideoEncodeRateControlFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn rate_control_mode(
         mut self,
         rate_control_mode: VideoEncodeRateControlModeFlagsKHR,
@@ -48987,245 +58670,401 @@ impl<'a> VideoEncodeRateControlInfoKHRBuilder<'a> {
         self.inner.rate_control_mode = rate_control_mode;
         self
     }
-    pub fn average_bitrate(mut self, average_bitrate: u32) -> Self {
+    #[inline]
+    pub fn layers(mut self, layers: &'a [VideoEncodeRateControlLayerInfoKHR]) -> Self {
+        self.inner.layer_count = layers.len() as _;
+        self.inner.p_layers = layers.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeRateControlInfoKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeRateControlLayerInfoKHR.html>"]
+pub struct VideoEncodeRateControlLayerInfoKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub average_bitrate: u64,
+    pub max_bitrate: u64,
+    pub frame_rate_numerator: u32,
+    pub frame_rate_denominator: u32,
+    pub virtual_buffer_size_in_ms: u32,
+    pub initial_virtual_buffer_size_in_ms: u32,
+}
+impl ::std::default::Default for VideoEncodeRateControlLayerInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            average_bitrate: u64::default(),
+            max_bitrate: u64::default(),
+            frame_rate_numerator: u32::default(),
+            frame_rate_denominator: u32::default(),
+            virtual_buffer_size_in_ms: u32::default(),
+            initial_virtual_buffer_size_in_ms: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeRateControlLayerInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR;
+}
+impl VideoEncodeRateControlLayerInfoKHR {
+    pub fn builder<'a>() -> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
+        VideoEncodeRateControlLayerInfoKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
+    inner: VideoEncodeRateControlLayerInfoKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHRBuilder<'_> {}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeRateControlLayerInfoKHR {}
+pub unsafe trait ExtendsVideoEncodeRateControlLayerInfoKHR {}
+impl<'a> ::std::ops::Deref for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
+    type Target = VideoEncodeRateControlLayerInfoKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeRateControlLayerInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn average_bitrate(mut self, average_bitrate: u64) -> Self {
         self.inner.average_bitrate = average_bitrate;
         self
     }
-    pub fn peak_to_average_bitrate_ratio(mut self, peak_to_average_bitrate_ratio: u16) -> Self {
-        self.inner.peak_to_average_bitrate_ratio = peak_to_average_bitrate_ratio;
+    #[inline]
+    pub fn max_bitrate(mut self, max_bitrate: u64) -> Self {
+        self.inner.max_bitrate = max_bitrate;
         self
     }
-    pub fn frame_rate_numerator(mut self, frame_rate_numerator: u16) -> Self {
+    #[inline]
+    pub fn frame_rate_numerator(mut self, frame_rate_numerator: u32) -> Self {
         self.inner.frame_rate_numerator = frame_rate_numerator;
         self
     }
-    pub fn frame_rate_denominator(mut self, frame_rate_denominator: u16) -> Self {
+    #[inline]
+    pub fn frame_rate_denominator(mut self, frame_rate_denominator: u32) -> Self {
         self.inner.frame_rate_denominator = frame_rate_denominator;
         self
     }
+    #[inline]
     pub fn virtual_buffer_size_in_ms(mut self, virtual_buffer_size_in_ms: u32) -> Self {
         self.inner.virtual_buffer_size_in_ms = virtual_buffer_size_in_ms;
         self
     }
+    #[inline]
+    pub fn initial_virtual_buffer_size_in_ms(
+        mut self,
+        initial_virtual_buffer_size_in_ms: u32,
+    ) -> Self {
+        self.inner.initial_virtual_buffer_size_in_ms = initial_virtual_buffer_size_in_ms;
+        self
+    }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsVideoEncodeRateControlLayerInfoKHR>(
+        mut self,
+        next: &'a mut T,
+    ) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoEncodeRateControlInfoKHR {
+    pub fn build(self) -> VideoEncodeRateControlLayerInfoKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264CapabilitiesEXT.html>"]
-pub struct VideoEncodeH264CapabilitiesEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeCapabilitiesKHR.html>"]
+pub struct VideoEncodeCapabilitiesKHR {
     pub s_type: StructureType,
-    pub p_next: *const c_void,
-    pub flags: VideoEncodeH264CapabilityFlagsEXT,
-    pub input_mode_flags: VideoEncodeH264InputModeFlagsEXT,
-    pub output_mode_flags: VideoEncodeH264OutputModeFlagsEXT,
-    pub min_picture_size_in_mbs: Extent2D,
-    pub max_picture_size_in_mbs: Extent2D,
-    pub input_image_data_alignment: Extent2D,
-    pub max_num_l0_reference_for_p: u8,
-    pub max_num_l0_reference_for_b: u8,
-    pub max_num_l1_reference: u8,
-    pub quality_level_count: u8,
-    pub std_extension_version: ExtensionProperties,
-}
-impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT {
-    fn default() -> VideoEncodeH264CapabilitiesEXT {
-        VideoEncodeH264CapabilitiesEXT {
-            s_type: StructureType::VIDEO_ENCODE_H264_CAPABILITIES_EXT,
-            p_next: ::std::ptr::null(),
-            flags: VideoEncodeH264CapabilityFlagsEXT::default(),
-            input_mode_flags: VideoEncodeH264InputModeFlagsEXT::default(),
-            output_mode_flags: VideoEncodeH264OutputModeFlagsEXT::default(),
-            min_picture_size_in_mbs: Extent2D::default(),
-            max_picture_size_in_mbs: Extent2D::default(),
-            input_image_data_alignment: Extent2D::default(),
-            max_num_l0_reference_for_p: u8::default(),
-            max_num_l0_reference_for_b: u8::default(),
-            max_num_l1_reference: u8::default(),
-            quality_level_count: u8::default(),
-            std_extension_version: ExtensionProperties::default(),
+    pub p_next: *mut c_void,
+    pub flags: VideoEncodeCapabilityFlagsKHR,
+    pub rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
+    pub max_rate_control_layers: u32,
+    pub max_quality_levels: u32,
+    pub input_image_data_fill_alignment: Extent2D,
+    pub supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
+}
+impl ::std::default::Default for VideoEncodeCapabilitiesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            flags: VideoEncodeCapabilityFlagsKHR::default(),
+            rate_control_modes: VideoEncodeRateControlModeFlagsKHR::default(),
+            max_rate_control_layers: u32::default(),
+            max_quality_levels: u32::default(),
+            input_image_data_fill_alignment: Extent2D::default(),
+            supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR::default(),
         }
     }
 }
-impl VideoEncodeH264CapabilitiesEXT {
-    pub fn builder<'a>() -> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
-        VideoEncodeH264CapabilitiesEXTBuilder {
-            inner: VideoEncodeH264CapabilitiesEXT::default(),
+unsafe impl TaggedStructure for VideoEncodeCapabilitiesKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_CAPABILITIES_KHR;
+}
+impl VideoEncodeCapabilitiesKHR {
+    pub fn builder<'a>() -> VideoEncodeCapabilitiesKHRBuilder<'a> {
+        VideoEncodeCapabilitiesKHRBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoEncodeH264CapabilitiesEXTBuilder<'a> {
-    inner: VideoEncodeH264CapabilitiesEXT,
+pub struct VideoEncodeCapabilitiesKHRBuilder<'a> {
+    inner: VideoEncodeCapabilitiesKHR,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXTBuilder<'_> {}
-unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXT {}
-impl<'a> ::std::ops::Deref for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
-    type Target = VideoEncodeH264CapabilitiesEXT;
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHRBuilder<'_> {}
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeCapabilitiesKHR {}
+impl<'a> ::std::ops::Deref for VideoEncodeCapabilitiesKHRBuilder<'a> {
+    type Target = VideoEncodeCapabilitiesKHR;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoEncodeCapabilitiesKHRBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
-    pub fn flags(mut self, flags: VideoEncodeH264CapabilityFlagsEXT) -> Self {
+impl<'a> VideoEncodeCapabilitiesKHRBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: VideoEncodeCapabilityFlagsKHR) -> Self {
         self.inner.flags = flags;
         self
     }
-    pub fn input_mode_flags(mut self, input_mode_flags: VideoEncodeH264InputModeFlagsEXT) -> Self {
-        self.inner.input_mode_flags = input_mode_flags;
-        self
-    }
-    pub fn output_mode_flags(
+    #[inline]
+    pub fn rate_control_modes(
         mut self,
-        output_mode_flags: VideoEncodeH264OutputModeFlagsEXT,
+        rate_control_modes: VideoEncodeRateControlModeFlagsKHR,
     ) -> Self {
-        self.inner.output_mode_flags = output_mode_flags;
-        self
-    }
-    pub fn min_picture_size_in_mbs(mut self, min_picture_size_in_mbs: Extent2D) -> Self {
-        self.inner.min_picture_size_in_mbs = min_picture_size_in_mbs;
-        self
-    }
-    pub fn max_picture_size_in_mbs(mut self, max_picture_size_in_mbs: Extent2D) -> Self {
-        self.inner.max_picture_size_in_mbs = max_picture_size_in_mbs;
+        self.inner.rate_control_modes = rate_control_modes;
         self
     }
-    pub fn input_image_data_alignment(mut self, input_image_data_alignment: Extent2D) -> Self {
-        self.inner.input_image_data_alignment = input_image_data_alignment;
+    #[inline]
+    pub fn max_rate_control_layers(mut self, max_rate_control_layers: u32) -> Self {
+        self.inner.max_rate_control_layers = max_rate_control_layers;
         self
     }
-    pub fn max_num_l0_reference_for_p(mut self, max_num_l0_reference_for_p: u8) -> Self {
-        self.inner.max_num_l0_reference_for_p = max_num_l0_reference_for_p;
+    #[inline]
+    pub fn max_quality_levels(mut self, max_quality_levels: u32) -> Self {
+        self.inner.max_quality_levels = max_quality_levels;
         self
     }
-    pub fn max_num_l0_reference_for_b(mut self, max_num_l0_reference_for_b: u8) -> Self {
-        self.inner.max_num_l0_reference_for_b = max_num_l0_reference_for_b;
-        self
-    }
-    pub fn max_num_l1_reference(mut self, max_num_l1_reference: u8) -> Self {
-        self.inner.max_num_l1_reference = max_num_l1_reference;
-        self
-    }
-    pub fn quality_level_count(mut self, quality_level_count: u8) -> Self {
-        self.inner.quality_level_count = quality_level_count;
+    #[inline]
+    pub fn input_image_data_fill_alignment(
+        mut self,
+        input_image_data_fill_alignment: Extent2D,
+    ) -> Self {
+        self.inner.input_image_data_fill_alignment = input_image_data_fill_alignment;
         self
     }
-    pub fn std_extension_version(mut self, std_extension_version: ExtensionProperties) -> Self {
-        self.inner.std_extension_version = std_extension_version;
+    #[inline]
+    pub fn supported_encode_feedback_flags(
+        mut self,
+        supported_encode_feedback_flags: VideoEncodeFeedbackFlagsKHR,
+    ) -> Self {
+        self.inner.supported_encode_feedback_flags = supported_encode_feedback_flags;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoEncodeH264CapabilitiesEXT {
+    pub fn build(self) -> VideoEncodeCapabilitiesKHR {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264SessionCreateInfoEXT.html>"]
-pub struct VideoEncodeH264SessionCreateInfoEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264CapabilitiesEXT.html>"]
+pub struct VideoEncodeH264CapabilitiesEXT {
     pub s_type: StructureType,
-    pub p_next: *const c_void,
-    pub flags: VideoEncodeH264CreateFlagsEXT,
-    pub max_picture_size_in_mbs: Extent2D,
-    pub p_std_extension_version: *const ExtensionProperties,
+    pub p_next: *mut c_void,
+    pub flags: VideoEncodeH264CapabilityFlagsEXT,
+    pub max_p_picture_l0_reference_count: u32,
+    pub max_b_picture_l0_reference_count: u32,
+    pub max_l1_reference_count: u32,
+    pub motion_vectors_over_pic_boundaries_flag: Bool32,
+    pub max_bytes_per_pic_denom: u32,
+    pub max_bits_per_mb_denom: u32,
+    pub log2_max_mv_length_horizontal: u32,
+    pub log2_max_mv_length_vertical: u32,
 }
-impl ::std::default::Default for VideoEncodeH264SessionCreateInfoEXT {
-    fn default() -> VideoEncodeH264SessionCreateInfoEXT {
-        VideoEncodeH264SessionCreateInfoEXT {
-            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT,
-            p_next: ::std::ptr::null(),
-            flags: VideoEncodeH264CreateFlagsEXT::default(),
-            max_picture_size_in_mbs: Extent2D::default(),
-            p_std_extension_version: ::std::ptr::null(),
+impl ::std::default::Default for VideoEncodeH264CapabilitiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            flags: VideoEncodeH264CapabilityFlagsEXT::default(),
+            max_p_picture_l0_reference_count: u32::default(),
+            max_b_picture_l0_reference_count: u32::default(),
+            max_l1_reference_count: u32::default(),
+            motion_vectors_over_pic_boundaries_flag: Bool32::default(),
+            max_bytes_per_pic_denom: u32::default(),
+            max_bits_per_mb_denom: u32::default(),
+            log2_max_mv_length_horizontal: u32::default(),
+            log2_max_mv_length_vertical: u32::default(),
         }
     }
 }
-impl VideoEncodeH264SessionCreateInfoEXT {
-    pub fn builder<'a>() -> VideoEncodeH264SessionCreateInfoEXTBuilder<'a> {
-        VideoEncodeH264SessionCreateInfoEXTBuilder {
-            inner: VideoEncodeH264SessionCreateInfoEXT::default(),
+unsafe impl TaggedStructure for VideoEncodeH264CapabilitiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_CAPABILITIES_EXT;
+}
+impl VideoEncodeH264CapabilitiesEXT {
+    pub fn builder<'a>() -> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
+        VideoEncodeH264CapabilitiesEXTBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoEncodeH264SessionCreateInfoEXTBuilder<'a> {
-    inner: VideoEncodeH264SessionCreateInfoEXT,
+pub struct VideoEncodeH264CapabilitiesEXTBuilder<'a> {
+    inner: VideoEncodeH264CapabilitiesEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH264SessionCreateInfoEXTBuilder<'_> {}
-unsafe impl ExtendsVideoSessionCreateInfoKHR for VideoEncodeH264SessionCreateInfoEXT {}
-impl<'a> ::std::ops::Deref for VideoEncodeH264SessionCreateInfoEXTBuilder<'a> {
-    type Target = VideoEncodeH264SessionCreateInfoEXT;
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXTBuilder<'_> {}
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH264CapabilitiesEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
+    type Target = VideoEncodeH264CapabilitiesEXT;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionCreateInfoEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264CapabilitiesEXTBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoEncodeH264SessionCreateInfoEXTBuilder<'a> {
-    pub fn flags(mut self, flags: VideoEncodeH264CreateFlagsEXT) -> Self {
+impl<'a> VideoEncodeH264CapabilitiesEXTBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: VideoEncodeH264CapabilityFlagsEXT) -> Self {
         self.inner.flags = flags;
         self
     }
-    pub fn max_picture_size_in_mbs(mut self, max_picture_size_in_mbs: Extent2D) -> Self {
-        self.inner.max_picture_size_in_mbs = max_picture_size_in_mbs;
+    #[inline]
+    pub fn max_p_picture_l0_reference_count(
+        mut self,
+        max_p_picture_l0_reference_count: u32,
+    ) -> Self {
+        self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count;
+        self
+    }
+    #[inline]
+    pub fn max_b_picture_l0_reference_count(
+        mut self,
+        max_b_picture_l0_reference_count: u32,
+    ) -> Self {
+        self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count;
+        self
+    }
+    #[inline]
+    pub fn max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self {
+        self.inner.max_l1_reference_count = max_l1_reference_count;
         self
     }
-    pub fn std_extension_version(mut self, std_extension_version: &'a ExtensionProperties) -> Self {
-        self.inner.p_std_extension_version = std_extension_version;
+    #[inline]
+    pub fn motion_vectors_over_pic_boundaries_flag(
+        mut self,
+        motion_vectors_over_pic_boundaries_flag: bool,
+    ) -> Self {
+        self.inner.motion_vectors_over_pic_boundaries_flag =
+            motion_vectors_over_pic_boundaries_flag.into();
+        self
+    }
+    #[inline]
+    pub fn max_bytes_per_pic_denom(mut self, max_bytes_per_pic_denom: u32) -> Self {
+        self.inner.max_bytes_per_pic_denom = max_bytes_per_pic_denom;
+        self
+    }
+    #[inline]
+    pub fn max_bits_per_mb_denom(mut self, max_bits_per_mb_denom: u32) -> Self {
+        self.inner.max_bits_per_mb_denom = max_bits_per_mb_denom;
+        self
+    }
+    #[inline]
+    pub fn log2_max_mv_length_horizontal(mut self, log2_max_mv_length_horizontal: u32) -> Self {
+        self.inner.log2_max_mv_length_horizontal = log2_max_mv_length_horizontal;
+        self
+    }
+    #[inline]
+    pub fn log2_max_mv_length_vertical(mut self, log2_max_mv_length_vertical: u32) -> Self {
+        self.inner.log2_max_mv_length_vertical = log2_max_mv_length_vertical;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoEncodeH264SessionCreateInfoEXT {
+    pub fn build(self) -> VideoEncodeH264CapabilitiesEXT {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264SessionParametersAddInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264SessionParametersAddInfoEXT.html>"]
 pub struct VideoEncodeH264SessionParametersAddInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub sps_std_count: u32,
-    pub p_sps_std: *const StdVideoH264SequenceParameterSet,
-    pub pps_std_count: u32,
-    pub p_pps_std: *const StdVideoH264PictureParameterSet,
+    pub std_sps_count: u32,
+    pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet,
+    pub std_pps_count: u32,
+    pub p_std_pp_ss: *const StdVideoH264PictureParameterSet,
 }
 impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT {
-    fn default() -> VideoEncodeH264SessionParametersAddInfoEXT {
-        VideoEncodeH264SessionParametersAddInfoEXT {
-            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            sps_std_count: u32::default(),
-            p_sps_std: ::std::ptr::null(),
-            pps_std_count: u32::default(),
-            p_pps_std: ::std::ptr::null(),
+            std_sps_count: u32::default(),
+            p_std_sp_ss: ::std::ptr::null(),
+            std_pps_count: u32::default(),
+            p_std_pp_ss: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoEncodeH264SessionParametersAddInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT;
+}
 impl VideoEncodeH264SessionParametersAddInfoEXT {
     pub fn builder<'a>() -> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
         VideoEncodeH264SessionParametersAddInfoEXTBuilder {
-            inner: VideoEncodeH264SessionParametersAddInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -49255,14 +59094,16 @@ impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersAddInfoEXTBuil
     }
 }
 impl<'a> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
-    pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self {
-        self.inner.sps_std_count = sps_std.len() as _;
-        self.inner.p_sps_std = sps_std.as_ptr();
+    #[inline]
+    pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self {
+        self.inner.std_sps_count = std_sp_ss.len() as _;
+        self.inner.p_std_sp_ss = std_sp_ss.as_ptr();
         self
     }
-    pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self {
-        self.inner.pps_std_count = pps_std.len() as _;
-        self.inner.p_pps_std = pps_std.as_ptr();
+    #[inline]
+    pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self {
+        self.inner.std_pps_count = std_pp_ss.len() as _;
+        self.inner.p_std_pp_ss = std_pp_ss.as_ptr();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -49273,30 +59114,36 @@ impl<'a> VideoEncodeH264SessionParametersAddInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264SessionParametersCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264SessionParametersCreateInfoEXT.html>"]
 pub struct VideoEncodeH264SessionParametersCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub max_sps_std_count: u32,
-    pub max_pps_std_count: u32,
+    pub max_std_sps_count: u32,
+    pub max_std_pps_count: u32,
     pub p_parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoEXT,
 }
 impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT {
-    fn default() -> VideoEncodeH264SessionParametersCreateInfoEXT {
-        VideoEncodeH264SessionParametersCreateInfoEXT {
-            s_type: StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            max_sps_std_count: u32::default(),
-            max_pps_std_count: u32::default(),
+            max_std_sps_count: u32::default(),
+            max_std_pps_count: u32::default(),
             p_parameters_add_info: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoEncodeH264SessionParametersCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT;
+}
 impl VideoEncodeH264SessionParametersCreateInfoEXT {
     pub fn builder<'a>() -> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
         VideoEncodeH264SessionParametersCreateInfoEXTBuilder {
-            inner: VideoEncodeH264SessionParametersCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -49326,14 +59173,17 @@ impl<'a> ::std::ops::DerefMut for VideoEncodeH264SessionParametersCreateInfoEXTB
     }
 }
 impl<'a> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
-    pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self {
-        self.inner.max_sps_std_count = max_sps_std_count;
+    #[inline]
+    pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self {
+        self.inner.max_std_sps_count = max_std_sps_count;
         self
     }
-    pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self {
-        self.inner.max_pps_std_count = max_pps_std_count;
+    #[inline]
+    pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self {
+        self.inner.max_std_pps_count = max_std_pps_count;
         self
     }
+    #[inline]
     pub fn parameters_add_info(
         mut self,
         parameters_add_info: &'a VideoEncodeH264SessionParametersAddInfoEXT,
@@ -49349,28 +59199,31 @@ impl<'a> VideoEncodeH264SessionParametersCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264DpbSlotInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264DpbSlotInfoEXT.html>"]
 pub struct VideoEncodeH264DpbSlotInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub slot_index: i8,
-    pub p_std_picture_info: *const StdVideoEncodeH264PictureInfo,
+    pub p_std_reference_info: *const StdVideoEncodeH264ReferenceInfo,
 }
 impl ::std::default::Default for VideoEncodeH264DpbSlotInfoEXT {
-    fn default() -> VideoEncodeH264DpbSlotInfoEXT {
-        VideoEncodeH264DpbSlotInfoEXT {
-            s_type: StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            slot_index: i8::default(),
-            p_std_picture_info: ::std::ptr::null(),
+            p_std_reference_info: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoEncodeH264DpbSlotInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT;
+}
 impl VideoEncodeH264DpbSlotInfoEXT {
     pub fn builder<'a>() -> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
         VideoEncodeH264DpbSlotInfoEXTBuilder {
-            inner: VideoEncodeH264DpbSlotInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -49380,6 +59233,8 @@ pub struct VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
     inner: VideoEncodeH264DpbSlotInfoEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
+unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH264DpbSlotInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH264DpbSlotInfoEXT {}
 impl<'a> ::std::ops::Deref for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
     type Target = VideoEncodeH264DpbSlotInfoEXT;
     fn deref(&self) -> &Self::Target {
@@ -49392,12 +59247,12 @@ impl<'a> ::std::ops::DerefMut for VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
     }
 }
 impl<'a> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
-    pub fn slot_index(mut self, slot_index: i8) -> Self {
-        self.inner.slot_index = slot_index;
-        self
-    }
-    pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoEncodeH264PictureInfo) -> Self {
-        self.inner.p_std_picture_info = std_picture_info;
+    #[inline]
+    pub fn std_reference_info(
+        mut self,
+        std_reference_info: &'a StdVideoEncodeH264ReferenceInfo,
+    ) -> Self {
+        self.inner.p_std_reference_info = std_reference_info;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -49408,38 +59263,37 @@ impl<'a> VideoEncodeH264DpbSlotInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264VclFrameInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264VclFrameInfoEXT.html>"]
 pub struct VideoEncodeH264VclFrameInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub ref_default_final_list0_entry_count: u8,
-    pub p_ref_default_final_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT,
-    pub ref_default_final_list1_entry_count: u8,
-    pub p_ref_default_final_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT,
+    pub p_std_reference_final_lists: *const StdVideoEncodeH264ReferenceListsInfo,
     pub nalu_slice_entry_count: u32,
-    pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceEXT,
-    pub p_current_picture_info: *const VideoEncodeH264DpbSlotInfoEXT,
+    pub p_nalu_slice_entries: *const VideoEncodeH264NaluSliceInfoEXT,
+    pub p_std_picture_info: *const StdVideoEncodeH264PictureInfo,
 }
 impl ::std::default::Default for VideoEncodeH264VclFrameInfoEXT {
-    fn default() -> VideoEncodeH264VclFrameInfoEXT {
-        VideoEncodeH264VclFrameInfoEXT {
-            s_type: StructureType::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT,
-            p_next: ::std::ptr::null(),
-            ref_default_final_list0_entry_count: u8::default(),
-            p_ref_default_final_list0_entries: ::std::ptr::null(),
-            ref_default_final_list1_entry_count: u8::default(),
-            p_ref_default_final_list1_entries: ::std::ptr::null(),
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            p_std_reference_final_lists: ::std::ptr::null(),
             nalu_slice_entry_count: u32::default(),
             p_nalu_slice_entries: ::std::ptr::null(),
-            p_current_picture_info: ::std::ptr::null(),
+            p_std_picture_info: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for VideoEncodeH264VclFrameInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT;
+}
 impl VideoEncodeH264VclFrameInfoEXT {
     pub fn builder<'a>() -> VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
         VideoEncodeH264VclFrameInfoEXTBuilder {
-            inner: VideoEncodeH264VclFrameInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -49463,291 +59317,1550 @@ impl<'a> ::std::ops::DerefMut for VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
     }
 }
 impl<'a> VideoEncodeH264VclFrameInfoEXTBuilder<'a> {
-    pub fn ref_default_final_list0_entries(
+    #[inline]
+    pub fn std_reference_final_lists(
         mut self,
-        ref_default_final_list0_entries: &'a [VideoEncodeH264DpbSlotInfoEXT],
+        std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo,
     ) -> Self {
-        self.inner.ref_default_final_list0_entry_count = ref_default_final_list0_entries.len() as _;
-        self.inner.p_ref_default_final_list0_entries = ref_default_final_list0_entries.as_ptr();
+        self.inner.p_std_reference_final_lists = std_reference_final_lists;
         self
     }
-    pub fn ref_default_final_list1_entries(
+    #[inline]
+    pub fn nalu_slice_entries(
         mut self,
-        ref_default_final_list1_entries: &'a [VideoEncodeH264DpbSlotInfoEXT],
+        nalu_slice_entries: &'a [VideoEncodeH264NaluSliceInfoEXT],
     ) -> Self {
-        self.inner.ref_default_final_list1_entry_count = ref_default_final_list1_entries.len() as _;
-        self.inner.p_ref_default_final_list1_entries = ref_default_final_list1_entries.as_ptr();
+        self.inner.nalu_slice_entry_count = nalu_slice_entries.len() as _;
+        self.inner.p_nalu_slice_entries = nalu_slice_entries.as_ptr();
         self
     }
-    pub fn nalu_slice_entries(
+    #[inline]
+    pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoEncodeH264PictureInfo) -> Self {
+        self.inner.p_std_picture_info = std_picture_info;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH264VclFrameInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264ProfileInfoEXT.html>"]
+pub struct VideoEncodeH264ProfileInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub std_profile_idc: StdVideoH264ProfileIdc,
+}
+impl ::std::default::Default for VideoEncodeH264ProfileInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            std_profile_idc: StdVideoH264ProfileIdc::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH264ProfileInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_PROFILE_INFO_EXT;
+}
+impl VideoEncodeH264ProfileInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH264ProfileInfoEXTBuilder<'a> {
+        VideoEncodeH264ProfileInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264ProfileInfoEXTBuilder<'a> {
+    inner: VideoEncodeH264ProfileInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH264ProfileInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH264ProfileInfoEXT {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileInfoEXTBuilder<'_> {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH264ProfileInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH264ProfileInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264ProfileInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264ProfileInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self {
+        self.inner.std_profile_idc = std_profile_idc;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH264ProfileInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264NaluSliceInfoEXT.html>"]
+pub struct VideoEncodeH264NaluSliceInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub mb_count: u32,
+    pub p_std_reference_final_lists: *const StdVideoEncodeH264ReferenceListsInfo,
+    pub p_std_slice_header: *const StdVideoEncodeH264SliceHeader,
+}
+impl ::std::default::Default for VideoEncodeH264NaluSliceInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            mb_count: u32::default(),
+            p_std_reference_final_lists: ::std::ptr::null(),
+            p_std_slice_header: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH264NaluSliceInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT;
+}
+impl VideoEncodeH264NaluSliceInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
+        VideoEncodeH264NaluSliceInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
+    inner: VideoEncodeH264NaluSliceInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH264NaluSliceInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264NaluSliceInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn mb_count(mut self, mb_count: u32) -> Self {
+        self.inner.mb_count = mb_count;
+        self
+    }
+    #[inline]
+    pub fn std_reference_final_lists(
         mut self,
-        nalu_slice_entries: &'a [VideoEncodeH264NaluSliceEXT],
+        std_reference_final_lists: &'a StdVideoEncodeH264ReferenceListsInfo,
     ) -> Self {
-        self.inner.nalu_slice_entry_count = nalu_slice_entries.len() as _;
-        self.inner.p_nalu_slice_entries = nalu_slice_entries.as_ptr();
+        self.inner.p_std_reference_final_lists = std_reference_final_lists;
+        self
+    }
+    #[inline]
+    pub fn std_slice_header(mut self, std_slice_header: &'a StdVideoEncodeH264SliceHeader) -> Self {
+        self.inner.p_std_slice_header = std_slice_header;
         self
     }
-    pub fn current_picture_info(
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH264NaluSliceInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlInfoEXT.html>"]
+pub struct VideoEncodeH264RateControlInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub gop_frame_count: u32,
+    pub idr_period: u32,
+    pub consecutive_b_frame_count: u32,
+    pub rate_control_structure: VideoEncodeH264RateControlStructureEXT,
+    pub temporal_layer_count: u32,
+}
+impl ::std::default::Default for VideoEncodeH264RateControlInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            gop_frame_count: u32::default(),
+            idr_period: u32::default(),
+            consecutive_b_frame_count: u32::default(),
+            rate_control_structure: VideoEncodeH264RateControlStructureEXT::default(),
+            temporal_layer_count: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH264RateControlInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT;
+}
+impl VideoEncodeH264RateControlInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+        VideoEncodeH264RateControlInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+    inner: VideoEncodeH264RateControlInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH264RateControlInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264RateControlInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
+        self.inner.gop_frame_count = gop_frame_count;
+        self
+    }
+    #[inline]
+    pub fn idr_period(mut self, idr_period: u32) -> Self {
+        self.inner.idr_period = idr_period;
+        self
+    }
+    #[inline]
+    pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
+        self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
+        self
+    }
+    #[inline]
+    pub fn rate_control_structure(
         mut self,
-        current_picture_info: &'a VideoEncodeH264DpbSlotInfoEXT,
+        rate_control_structure: VideoEncodeH264RateControlStructureEXT,
     ) -> Self {
-        self.inner.p_current_picture_info = current_picture_info;
+        self.inner.rate_control_structure = rate_control_structure;
+        self
+    }
+    #[inline]
+    pub fn temporal_layer_count(mut self, temporal_layer_count: u32) -> Self {
+        self.inner.temporal_layer_count = temporal_layer_count;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoEncodeH264VclFrameInfoEXT {
+    pub fn build(self) -> VideoEncodeH264RateControlInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264QpEXT.html>"]
+pub struct VideoEncodeH264QpEXT {
+    pub qp_i: i32,
+    pub qp_p: i32,
+    pub qp_b: i32,
+}
+impl VideoEncodeH264QpEXT {
+    pub fn builder<'a>() -> VideoEncodeH264QpEXTBuilder<'a> {
+        VideoEncodeH264QpEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264QpEXTBuilder<'a> {
+    inner: VideoEncodeH264QpEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH264QpEXTBuilder<'a> {
+    type Target = VideoEncodeH264QpEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264QpEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264QpEXTBuilder<'a> {
+    #[inline]
+    pub fn qp_i(mut self, qp_i: i32) -> Self {
+        self.inner.qp_i = qp_i;
+        self
+    }
+    #[inline]
+    pub fn qp_p(mut self, qp_p: i32) -> Self {
+        self.inner.qp_p = qp_p;
+        self
+    }
+    #[inline]
+    pub fn qp_b(mut self, qp_b: i32) -> Self {
+        self.inner.qp_b = qp_b;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH264QpEXT {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264EmitPictureParametersEXT.html>"]
-pub struct VideoEncodeH264EmitPictureParametersEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264FrameSizeEXT.html>"]
+pub struct VideoEncodeH264FrameSizeEXT {
+    pub frame_i_size: u32,
+    pub frame_p_size: u32,
+    pub frame_b_size: u32,
+}
+impl VideoEncodeH264FrameSizeEXT {
+    pub fn builder<'a>() -> VideoEncodeH264FrameSizeEXTBuilder<'a> {
+        VideoEncodeH264FrameSizeEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264FrameSizeEXTBuilder<'a> {
+    inner: VideoEncodeH264FrameSizeEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH264FrameSizeEXTBuilder<'a> {
+    type Target = VideoEncodeH264FrameSizeEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264FrameSizeEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264FrameSizeEXTBuilder<'a> {
+    #[inline]
+    pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
+        self.inner.frame_i_size = frame_i_size;
+        self
+    }
+    #[inline]
+    pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
+        self.inner.frame_p_size = frame_p_size;
+        self
+    }
+    #[inline]
+    pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
+        self.inner.frame_b_size = frame_b_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH264FrameSizeEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlLayerInfoEXT.html>"]
+pub struct VideoEncodeH264RateControlLayerInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub sps_id: u8,
-    pub emit_sps_enable: Bool32,
-    pub pps_id_entry_count: u32,
-    pub pps_id_entries: *const u8,
+    pub temporal_layer_id: u32,
+    pub use_initial_rc_qp: Bool32,
+    pub initial_rc_qp: VideoEncodeH264QpEXT,
+    pub use_min_qp: Bool32,
+    pub min_qp: VideoEncodeH264QpEXT,
+    pub use_max_qp: Bool32,
+    pub max_qp: VideoEncodeH264QpEXT,
+    pub use_max_frame_size: Bool32,
+    pub max_frame_size: VideoEncodeH264FrameSizeEXT,
+}
+impl ::std::default::Default for VideoEncodeH264RateControlLayerInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            temporal_layer_id: u32::default(),
+            use_initial_rc_qp: Bool32::default(),
+            initial_rc_qp: VideoEncodeH264QpEXT::default(),
+            use_min_qp: Bool32::default(),
+            min_qp: VideoEncodeH264QpEXT::default(),
+            use_max_qp: Bool32::default(),
+            max_qp: VideoEncodeH264QpEXT::default(),
+            use_max_frame_size: Bool32::default(),
+            max_frame_size: VideoEncodeH264FrameSizeEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH264RateControlLayerInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT;
 }
-impl ::std::default::Default for VideoEncodeH264EmitPictureParametersEXT {
-    fn default() -> VideoEncodeH264EmitPictureParametersEXT {
-        VideoEncodeH264EmitPictureParametersEXT {
-            s_type: StructureType::VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT,
+impl VideoEncodeH264RateControlLayerInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+        VideoEncodeH264RateControlLayerInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+    inner: VideoEncodeH264RateControlLayerInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {}
+unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
+    for VideoEncodeH264RateControlLayerInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH264RateControlLayerInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH264RateControlLayerInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH264RateControlLayerInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn temporal_layer_id(mut self, temporal_layer_id: u32) -> Self {
+        self.inner.temporal_layer_id = temporal_layer_id;
+        self
+    }
+    #[inline]
+    pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
+        self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
+        self
+    }
+    #[inline]
+    pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH264QpEXT) -> Self {
+        self.inner.initial_rc_qp = initial_rc_qp;
+        self
+    }
+    #[inline]
+    pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
+        self.inner.use_min_qp = use_min_qp.into();
+        self
+    }
+    #[inline]
+    pub fn min_qp(mut self, min_qp: VideoEncodeH264QpEXT) -> Self {
+        self.inner.min_qp = min_qp;
+        self
+    }
+    #[inline]
+    pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
+        self.inner.use_max_qp = use_max_qp.into();
+        self
+    }
+    #[inline]
+    pub fn max_qp(mut self, max_qp: VideoEncodeH264QpEXT) -> Self {
+        self.inner.max_qp = max_qp;
+        self
+    }
+    #[inline]
+    pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
+        self.inner.use_max_frame_size = use_max_frame_size.into();
+        self
+    }
+    #[inline]
+    pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH264FrameSizeEXT) -> Self {
+        self.inner.max_frame_size = max_frame_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH264RateControlLayerInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265CapabilitiesEXT.html>"]
+pub struct VideoEncodeH265CapabilitiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub flags: VideoEncodeH265CapabilityFlagsEXT,
+    pub ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT,
+    pub transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT,
+    pub max_p_picture_l0_reference_count: u32,
+    pub max_b_picture_l0_reference_count: u32,
+    pub max_l1_reference_count: u32,
+    pub max_sub_layers_count: u32,
+    pub min_log2_min_luma_coding_block_size_minus3: u32,
+    pub max_log2_min_luma_coding_block_size_minus3: u32,
+    pub min_log2_min_luma_transform_block_size_minus2: u32,
+    pub max_log2_min_luma_transform_block_size_minus2: u32,
+    pub min_max_transform_hierarchy_depth_inter: u32,
+    pub max_max_transform_hierarchy_depth_inter: u32,
+    pub min_max_transform_hierarchy_depth_intra: u32,
+    pub max_max_transform_hierarchy_depth_intra: u32,
+    pub max_diff_cu_qp_delta_depth: u32,
+    pub min_max_num_merge_cand: u32,
+    pub max_max_num_merge_cand: u32,
+}
+impl ::std::default::Default for VideoEncodeH265CapabilitiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            flags: VideoEncodeH265CapabilityFlagsEXT::default(),
+            ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT::default(),
+            transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT::default(),
+            max_p_picture_l0_reference_count: u32::default(),
+            max_b_picture_l0_reference_count: u32::default(),
+            max_l1_reference_count: u32::default(),
+            max_sub_layers_count: u32::default(),
+            min_log2_min_luma_coding_block_size_minus3: u32::default(),
+            max_log2_min_luma_coding_block_size_minus3: u32::default(),
+            min_log2_min_luma_transform_block_size_minus2: u32::default(),
+            max_log2_min_luma_transform_block_size_minus2: u32::default(),
+            min_max_transform_hierarchy_depth_inter: u32::default(),
+            max_max_transform_hierarchy_depth_inter: u32::default(),
+            min_max_transform_hierarchy_depth_intra: u32::default(),
+            max_max_transform_hierarchy_depth_intra: u32::default(),
+            max_diff_cu_qp_delta_depth: u32::default(),
+            min_max_num_merge_cand: u32::default(),
+            max_max_num_merge_cand: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH265CapabilitiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_CAPABILITIES_EXT;
+}
+impl VideoEncodeH265CapabilitiesEXT {
+    pub fn builder<'a>() -> VideoEncodeH265CapabilitiesEXTBuilder<'a> {
+        VideoEncodeH265CapabilitiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265CapabilitiesEXTBuilder<'a> {
+    inner: VideoEncodeH265CapabilitiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXTBuilder<'_> {}
+unsafe impl ExtendsVideoCapabilitiesKHR for VideoEncodeH265CapabilitiesEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH265CapabilitiesEXTBuilder<'a> {
+    type Target = VideoEncodeH265CapabilitiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265CapabilitiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265CapabilitiesEXTBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: VideoEncodeH265CapabilityFlagsEXT) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn ctb_sizes(mut self, ctb_sizes: VideoEncodeH265CtbSizeFlagsEXT) -> Self {
+        self.inner.ctb_sizes = ctb_sizes;
+        self
+    }
+    #[inline]
+    pub fn transform_block_sizes(
+        mut self,
+        transform_block_sizes: VideoEncodeH265TransformBlockSizeFlagsEXT,
+    ) -> Self {
+        self.inner.transform_block_sizes = transform_block_sizes;
+        self
+    }
+    #[inline]
+    pub fn max_p_picture_l0_reference_count(
+        mut self,
+        max_p_picture_l0_reference_count: u32,
+    ) -> Self {
+        self.inner.max_p_picture_l0_reference_count = max_p_picture_l0_reference_count;
+        self
+    }
+    #[inline]
+    pub fn max_b_picture_l0_reference_count(
+        mut self,
+        max_b_picture_l0_reference_count: u32,
+    ) -> Self {
+        self.inner.max_b_picture_l0_reference_count = max_b_picture_l0_reference_count;
+        self
+    }
+    #[inline]
+    pub fn max_l1_reference_count(mut self, max_l1_reference_count: u32) -> Self {
+        self.inner.max_l1_reference_count = max_l1_reference_count;
+        self
+    }
+    #[inline]
+    pub fn max_sub_layers_count(mut self, max_sub_layers_count: u32) -> Self {
+        self.inner.max_sub_layers_count = max_sub_layers_count;
+        self
+    }
+    #[inline]
+    pub fn min_log2_min_luma_coding_block_size_minus3(
+        mut self,
+        min_log2_min_luma_coding_block_size_minus3: u32,
+    ) -> Self {
+        self.inner.min_log2_min_luma_coding_block_size_minus3 =
+            min_log2_min_luma_coding_block_size_minus3;
+        self
+    }
+    #[inline]
+    pub fn max_log2_min_luma_coding_block_size_minus3(
+        mut self,
+        max_log2_min_luma_coding_block_size_minus3: u32,
+    ) -> Self {
+        self.inner.max_log2_min_luma_coding_block_size_minus3 =
+            max_log2_min_luma_coding_block_size_minus3;
+        self
+    }
+    #[inline]
+    pub fn min_log2_min_luma_transform_block_size_minus2(
+        mut self,
+        min_log2_min_luma_transform_block_size_minus2: u32,
+    ) -> Self {
+        self.inner.min_log2_min_luma_transform_block_size_minus2 =
+            min_log2_min_luma_transform_block_size_minus2;
+        self
+    }
+    #[inline]
+    pub fn max_log2_min_luma_transform_block_size_minus2(
+        mut self,
+        max_log2_min_luma_transform_block_size_minus2: u32,
+    ) -> Self {
+        self.inner.max_log2_min_luma_transform_block_size_minus2 =
+            max_log2_min_luma_transform_block_size_minus2;
+        self
+    }
+    #[inline]
+    pub fn min_max_transform_hierarchy_depth_inter(
+        mut self,
+        min_max_transform_hierarchy_depth_inter: u32,
+    ) -> Self {
+        self.inner.min_max_transform_hierarchy_depth_inter =
+            min_max_transform_hierarchy_depth_inter;
+        self
+    }
+    #[inline]
+    pub fn max_max_transform_hierarchy_depth_inter(
+        mut self,
+        max_max_transform_hierarchy_depth_inter: u32,
+    ) -> Self {
+        self.inner.max_max_transform_hierarchy_depth_inter =
+            max_max_transform_hierarchy_depth_inter;
+        self
+    }
+    #[inline]
+    pub fn min_max_transform_hierarchy_depth_intra(
+        mut self,
+        min_max_transform_hierarchy_depth_intra: u32,
+    ) -> Self {
+        self.inner.min_max_transform_hierarchy_depth_intra =
+            min_max_transform_hierarchy_depth_intra;
+        self
+    }
+    #[inline]
+    pub fn max_max_transform_hierarchy_depth_intra(
+        mut self,
+        max_max_transform_hierarchy_depth_intra: u32,
+    ) -> Self {
+        self.inner.max_max_transform_hierarchy_depth_intra =
+            max_max_transform_hierarchy_depth_intra;
+        self
+    }
+    #[inline]
+    pub fn max_diff_cu_qp_delta_depth(mut self, max_diff_cu_qp_delta_depth: u32) -> Self {
+        self.inner.max_diff_cu_qp_delta_depth = max_diff_cu_qp_delta_depth;
+        self
+    }
+    #[inline]
+    pub fn min_max_num_merge_cand(mut self, min_max_num_merge_cand: u32) -> Self {
+        self.inner.min_max_num_merge_cand = min_max_num_merge_cand;
+        self
+    }
+    #[inline]
+    pub fn max_max_num_merge_cand(mut self, max_max_num_merge_cand: u32) -> Self {
+        self.inner.max_max_num_merge_cand = max_max_num_merge_cand;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH265CapabilitiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265SessionParametersAddInfoEXT.html>"]
+pub struct VideoEncodeH265SessionParametersAddInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub std_vps_count: u32,
+    pub p_std_vp_ss: *const StdVideoH265VideoParameterSet,
+    pub std_sps_count: u32,
+    pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet,
+    pub std_pps_count: u32,
+    pub p_std_pp_ss: *const StdVideoH265PictureParameterSet,
+}
+impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            sps_id: u8::default(),
-            emit_sps_enable: Bool32::default(),
-            pps_id_entry_count: u32::default(),
-            pps_id_entries: ::std::ptr::null(),
+            std_vps_count: u32::default(),
+            p_std_vp_ss: ::std::ptr::null(),
+            std_sps_count: u32::default(),
+            p_std_sp_ss: ::std::ptr::null(),
+            std_pps_count: u32::default(),
+            p_std_pp_ss: ::std::ptr::null(),
         }
     }
 }
-impl VideoEncodeH264EmitPictureParametersEXT {
-    pub fn builder<'a>() -> VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
-        VideoEncodeH264EmitPictureParametersEXTBuilder {
-            inner: VideoEncodeH264EmitPictureParametersEXT::default(),
+unsafe impl TaggedStructure for VideoEncodeH265SessionParametersAddInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT;
+}
+impl VideoEncodeH265SessionParametersAddInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
+        VideoEncodeH265SessionParametersAddInfoEXTBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
-    inner: VideoEncodeH264EmitPictureParametersEXT,
+pub struct VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265SessionParametersAddInfoEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersEXTBuilder<'_> {}
-unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH264EmitPictureParametersEXT {}
-impl<'a> ::std::ops::Deref for VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
-    type Target = VideoEncodeH264EmitPictureParametersEXT;
+unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
+    for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR
+    for VideoEncodeH265SessionParametersAddInfoEXT
+{
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265SessionParametersAddInfoEXT;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoEncodeH264EmitPictureParametersEXTBuilder<'a> {
-    pub fn sps_id(mut self, sps_id: u8) -> Self {
-        self.inner.sps_id = sps_id;
+impl<'a> VideoEncodeH265SessionParametersAddInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self {
+        self.inner.std_vps_count = std_vp_ss.len() as _;
+        self.inner.p_std_vp_ss = std_vp_ss.as_ptr();
         self
     }
-    pub fn emit_sps_enable(mut self, emit_sps_enable: bool) -> Self {
-        self.inner.emit_sps_enable = emit_sps_enable.into();
+    #[inline]
+    pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self {
+        self.inner.std_sps_count = std_sp_ss.len() as _;
+        self.inner.p_std_sp_ss = std_sp_ss.as_ptr();
         self
     }
-    pub fn pps_id_entries(mut self, pps_id_entries: &'a [u8]) -> Self {
-        self.inner.pps_id_entry_count = pps_id_entries.len() as _;
-        self.inner.pps_id_entries = pps_id_entries.as_ptr();
+    #[inline]
+    pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self {
+        self.inner.std_pps_count = std_pp_ss.len() as _;
+        self.inner.p_std_pp_ss = std_pp_ss.as_ptr();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoEncodeH264EmitPictureParametersEXT {
+    pub fn build(self) -> VideoEncodeH265SessionParametersAddInfoEXT {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264ProfileEXT.html>"]
-pub struct VideoEncodeH264ProfileEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265SessionParametersCreateInfoEXT.html>"]
+pub struct VideoEncodeH265SessionParametersCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub std_profile_idc: StdVideoH264ProfileIdc,
+    pub max_std_vps_count: u32,
+    pub max_std_sps_count: u32,
+    pub max_std_pps_count: u32,
+    pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT,
+}
+impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            max_std_vps_count: u32::default(),
+            max_std_sps_count: u32::default(),
+            max_std_pps_count: u32::default(),
+            p_parameters_add_info: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH265SessionParametersCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT;
+}
+impl VideoEncodeH265SessionParametersCreateInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
+        VideoEncodeH265SessionParametersCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265SessionParametersCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
+    for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'_>
+{
 }
-impl ::std::default::Default for VideoEncodeH264ProfileEXT {
-    fn default() -> VideoEncodeH264ProfileEXT {
-        VideoEncodeH264ProfileEXT {
-            s_type: StructureType::VIDEO_ENCODE_H264_PROFILE_EXT,
+unsafe impl ExtendsVideoSessionParametersCreateInfoKHR
+    for VideoEncodeH265SessionParametersCreateInfoEXT
+{
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265SessionParametersCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265SessionParametersCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self {
+        self.inner.max_std_vps_count = max_std_vps_count;
+        self
+    }
+    #[inline]
+    pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self {
+        self.inner.max_std_sps_count = max_std_sps_count;
+        self
+    }
+    #[inline]
+    pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self {
+        self.inner.max_std_pps_count = max_std_pps_count;
+        self
+    }
+    #[inline]
+    pub fn parameters_add_info(
+        mut self,
+        parameters_add_info: &'a VideoEncodeH265SessionParametersAddInfoEXT,
+    ) -> Self {
+        self.inner.p_parameters_add_info = parameters_add_info;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH265SessionParametersCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265VclFrameInfoEXT.html>"]
+pub struct VideoEncodeH265VclFrameInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub p_std_reference_final_lists: *const StdVideoEncodeH265ReferenceListsInfo,
+    pub nalu_slice_segment_entry_count: u32,
+    pub p_nalu_slice_segment_entries: *const VideoEncodeH265NaluSliceSegmentInfoEXT,
+    pub p_std_picture_info: *const StdVideoEncodeH265PictureInfo,
+}
+impl ::std::default::Default for VideoEncodeH265VclFrameInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
-            std_profile_idc: StdVideoH264ProfileIdc::default(),
+            p_std_reference_final_lists: ::std::ptr::null(),
+            nalu_slice_segment_entry_count: u32::default(),
+            p_nalu_slice_segment_entries: ::std::ptr::null(),
+            p_std_picture_info: ::std::ptr::null(),
         }
     }
 }
-impl VideoEncodeH264ProfileEXT {
-    pub fn builder<'a>() -> VideoEncodeH264ProfileEXTBuilder<'a> {
-        VideoEncodeH264ProfileEXTBuilder {
-            inner: VideoEncodeH264ProfileEXT::default(),
+unsafe impl TaggedStructure for VideoEncodeH265VclFrameInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT;
+}
+impl VideoEncodeH265VclFrameInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
+        VideoEncodeH265VclFrameInfoEXTBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoEncodeH264ProfileEXTBuilder<'a> {
-    inner: VideoEncodeH264ProfileEXT,
+pub struct VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265VclFrameInfoEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXTBuilder<'_> {}
-unsafe impl ExtendsVideoProfileKHR for VideoEncodeH264ProfileEXT {}
-impl<'a> ::std::ops::Deref for VideoEncodeH264ProfileEXTBuilder<'a> {
-    type Target = VideoEncodeH264ProfileEXT;
+unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoEncodeInfoKHR for VideoEncodeH265VclFrameInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265VclFrameInfoEXT;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoEncodeH264ProfileEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoEncodeH264ProfileEXTBuilder<'a> {
-    pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH264ProfileIdc) -> Self {
-        self.inner.std_profile_idc = std_profile_idc;
+impl<'a> VideoEncodeH265VclFrameInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn std_reference_final_lists(
+        mut self,
+        std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo,
+    ) -> Self {
+        self.inner.p_std_reference_final_lists = std_reference_final_lists;
+        self
+    }
+    #[inline]
+    pub fn nalu_slice_segment_entries(
+        mut self,
+        nalu_slice_segment_entries: &'a [VideoEncodeH265NaluSliceSegmentInfoEXT],
+    ) -> Self {
+        self.inner.nalu_slice_segment_entry_count = nalu_slice_segment_entries.len() as _;
+        self.inner.p_nalu_slice_segment_entries = nalu_slice_segment_entries.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoEncodeH265PictureInfo) -> Self {
+        self.inner.p_std_picture_info = std_picture_info;
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoEncodeH264ProfileEXT {
+    pub fn build(self) -> VideoEncodeH265VclFrameInfoEXT {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVideoEncodeH264NaluSliceEXT.html>"]
-pub struct VideoEncodeH264NaluSliceEXT {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265NaluSliceSegmentInfoEXT.html>"]
+pub struct VideoEncodeH265NaluSliceSegmentInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
-    pub p_slice_header_std: *const StdVideoEncodeH264SliceHeader,
-    pub mb_count: u32,
-    pub ref_final_list0_entry_count: u8,
-    pub p_ref_final_list0_entries: *const VideoEncodeH264DpbSlotInfoEXT,
-    pub ref_final_list1_entry_count: u8,
-    pub p_ref_final_list1_entries: *const VideoEncodeH264DpbSlotInfoEXT,
-    pub preceding_nalu_bytes: u32,
-    pub min_qp: u8,
-    pub max_qp: u8,
-}
-impl ::std::default::Default for VideoEncodeH264NaluSliceEXT {
-    fn default() -> VideoEncodeH264NaluSliceEXT {
-        VideoEncodeH264NaluSliceEXT {
-            s_type: StructureType::VIDEO_ENCODE_H264_NALU_SLICE_EXT,
-            p_next: ::std::ptr::null(),
-            p_slice_header_std: ::std::ptr::null(),
-            mb_count: u32::default(),
-            ref_final_list0_entry_count: u8::default(),
-            p_ref_final_list0_entries: ::std::ptr::null(),
-            ref_final_list1_entry_count: u8::default(),
-            p_ref_final_list1_entries: ::std::ptr::null(),
-            preceding_nalu_bytes: u32::default(),
-            min_qp: u8::default(),
-            max_qp: u8::default(),
+    pub ctb_count: u32,
+    pub p_std_reference_final_lists: *const StdVideoEncodeH265ReferenceListsInfo,
+    pub p_std_slice_segment_header: *const StdVideoEncodeH265SliceSegmentHeader,
+}
+impl ::std::default::Default for VideoEncodeH265NaluSliceSegmentInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            ctb_count: u32::default(),
+            p_std_reference_final_lists: ::std::ptr::null(),
+            p_std_slice_segment_header: ::std::ptr::null(),
         }
     }
 }
-impl VideoEncodeH264NaluSliceEXT {
-    pub fn builder<'a>() -> VideoEncodeH264NaluSliceEXTBuilder<'a> {
-        VideoEncodeH264NaluSliceEXTBuilder {
-            inner: VideoEncodeH264NaluSliceEXT::default(),
+unsafe impl TaggedStructure for VideoEncodeH265NaluSliceSegmentInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT;
+}
+impl VideoEncodeH265NaluSliceSegmentInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
+        VideoEncodeH265NaluSliceSegmentInfoEXTBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct VideoEncodeH264NaluSliceEXTBuilder<'a> {
-    inner: VideoEncodeH264NaluSliceEXT,
+pub struct VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265NaluSliceSegmentInfoEXT,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
-impl<'a> ::std::ops::Deref for VideoEncodeH264NaluSliceEXTBuilder<'a> {
-    type Target = VideoEncodeH264NaluSliceEXT;
+impl<'a> ::std::ops::Deref for VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265NaluSliceSegmentInfoEXT;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for VideoEncodeH264NaluSliceEXTBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> VideoEncodeH264NaluSliceEXTBuilder<'a> {
-    pub fn slice_header_std(mut self, slice_header_std: &'a StdVideoEncodeH264SliceHeader) -> Self {
-        self.inner.p_slice_header_std = slice_header_std;
+impl<'a> VideoEncodeH265NaluSliceSegmentInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn ctb_count(mut self, ctb_count: u32) -> Self {
+        self.inner.ctb_count = ctb_count;
         self
     }
-    pub fn mb_count(mut self, mb_count: u32) -> Self {
-        self.inner.mb_count = mb_count;
+    #[inline]
+    pub fn std_reference_final_lists(
+        mut self,
+        std_reference_final_lists: &'a StdVideoEncodeH265ReferenceListsInfo,
+    ) -> Self {
+        self.inner.p_std_reference_final_lists = std_reference_final_lists;
         self
     }
-    pub fn ref_final_list0_entries(
+    #[inline]
+    pub fn std_slice_segment_header(
         mut self,
-        ref_final_list0_entries: &'a [VideoEncodeH264DpbSlotInfoEXT],
+        std_slice_segment_header: &'a StdVideoEncodeH265SliceSegmentHeader,
     ) -> Self {
-        self.inner.ref_final_list0_entry_count = ref_final_list0_entries.len() as _;
-        self.inner.p_ref_final_list0_entries = ref_final_list0_entries.as_ptr();
+        self.inner.p_std_slice_segment_header = std_slice_segment_header;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH265NaluSliceSegmentInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlInfoEXT.html>"]
+pub struct VideoEncodeH265RateControlInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub gop_frame_count: u32,
+    pub idr_period: u32,
+    pub consecutive_b_frame_count: u32,
+    pub rate_control_structure: VideoEncodeH265RateControlStructureEXT,
+    pub sub_layer_count: u32,
+}
+impl ::std::default::Default for VideoEncodeH265RateControlInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            gop_frame_count: u32::default(),
+            idr_period: u32::default(),
+            consecutive_b_frame_count: u32::default(),
+            rate_control_structure: VideoEncodeH265RateControlStructureEXT::default(),
+            sub_layer_count: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH265RateControlInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT;
+}
+impl VideoEncodeH265RateControlInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+        VideoEncodeH265RateControlInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265RateControlInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265RateControlInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265RateControlInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn gop_frame_count(mut self, gop_frame_count: u32) -> Self {
+        self.inner.gop_frame_count = gop_frame_count;
+        self
+    }
+    #[inline]
+    pub fn idr_period(mut self, idr_period: u32) -> Self {
+        self.inner.idr_period = idr_period;
         self
     }
-    pub fn ref_final_list1_entries(
+    #[inline]
+    pub fn consecutive_b_frame_count(mut self, consecutive_b_frame_count: u32) -> Self {
+        self.inner.consecutive_b_frame_count = consecutive_b_frame_count;
+        self
+    }
+    #[inline]
+    pub fn rate_control_structure(
         mut self,
-        ref_final_list1_entries: &'a [VideoEncodeH264DpbSlotInfoEXT],
+        rate_control_structure: VideoEncodeH265RateControlStructureEXT,
     ) -> Self {
-        self.inner.ref_final_list1_entry_count = ref_final_list1_entries.len() as _;
-        self.inner.p_ref_final_list1_entries = ref_final_list1_entries.as_ptr();
+        self.inner.rate_control_structure = rate_control_structure;
+        self
+    }
+    #[inline]
+    pub fn sub_layer_count(mut self, sub_layer_count: u32) -> Self {
+        self.inner.sub_layer_count = sub_layer_count;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH265RateControlInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265QpEXT.html>"]
+pub struct VideoEncodeH265QpEXT {
+    pub qp_i: i32,
+    pub qp_p: i32,
+    pub qp_b: i32,
+}
+impl VideoEncodeH265QpEXT {
+    pub fn builder<'a>() -> VideoEncodeH265QpEXTBuilder<'a> {
+        VideoEncodeH265QpEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265QpEXTBuilder<'a> {
+    inner: VideoEncodeH265QpEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH265QpEXTBuilder<'a> {
+    type Target = VideoEncodeH265QpEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265QpEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265QpEXTBuilder<'a> {
+    #[inline]
+    pub fn qp_i(mut self, qp_i: i32) -> Self {
+        self.inner.qp_i = qp_i;
+        self
+    }
+    #[inline]
+    pub fn qp_p(mut self, qp_p: i32) -> Self {
+        self.inner.qp_p = qp_p;
+        self
+    }
+    #[inline]
+    pub fn qp_b(mut self, qp_b: i32) -> Self {
+        self.inner.qp_b = qp_b;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH265QpEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265FrameSizeEXT.html>"]
+pub struct VideoEncodeH265FrameSizeEXT {
+    pub frame_i_size: u32,
+    pub frame_p_size: u32,
+    pub frame_b_size: u32,
+}
+impl VideoEncodeH265FrameSizeEXT {
+    pub fn builder<'a>() -> VideoEncodeH265FrameSizeEXTBuilder<'a> {
+        VideoEncodeH265FrameSizeEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265FrameSizeEXTBuilder<'a> {
+    inner: VideoEncodeH265FrameSizeEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for VideoEncodeH265FrameSizeEXTBuilder<'a> {
+    type Target = VideoEncodeH265FrameSizeEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265FrameSizeEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265FrameSizeEXTBuilder<'a> {
+    #[inline]
+    pub fn frame_i_size(mut self, frame_i_size: u32) -> Self {
+        self.inner.frame_i_size = frame_i_size;
+        self
+    }
+    #[inline]
+    pub fn frame_p_size(mut self, frame_p_size: u32) -> Self {
+        self.inner.frame_p_size = frame_p_size;
+        self
+    }
+    #[inline]
+    pub fn frame_b_size(mut self, frame_b_size: u32) -> Self {
+        self.inner.frame_b_size = frame_b_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH265FrameSizeEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlLayerInfoEXT.html>"]
+pub struct VideoEncodeH265RateControlLayerInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub temporal_id: u32,
+    pub use_initial_rc_qp: Bool32,
+    pub initial_rc_qp: VideoEncodeH265QpEXT,
+    pub use_min_qp: Bool32,
+    pub min_qp: VideoEncodeH265QpEXT,
+    pub use_max_qp: Bool32,
+    pub max_qp: VideoEncodeH265QpEXT,
+    pub use_max_frame_size: Bool32,
+    pub max_frame_size: VideoEncodeH265FrameSizeEXT,
+}
+impl ::std::default::Default for VideoEncodeH265RateControlLayerInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            temporal_id: u32::default(),
+            use_initial_rc_qp: Bool32::default(),
+            initial_rc_qp: VideoEncodeH265QpEXT::default(),
+            use_min_qp: Bool32::default(),
+            min_qp: VideoEncodeH265QpEXT::default(),
+            use_max_qp: Bool32::default(),
+            max_qp: VideoEncodeH265QpEXT::default(),
+            use_max_frame_size: Bool32::default(),
+            max_frame_size: VideoEncodeH265FrameSizeEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH265RateControlLayerInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT;
+}
+impl VideoEncodeH265RateControlLayerInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+        VideoEncodeH265RateControlLayerInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265RateControlLayerInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoCodingControlInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {}
+unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR
+    for VideoEncodeH265RateControlLayerInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsVideoEncodeRateControlLayerInfoKHR for VideoEncodeH265RateControlLayerInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265RateControlLayerInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265RateControlLayerInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn temporal_id(mut self, temporal_id: u32) -> Self {
+        self.inner.temporal_id = temporal_id;
+        self
+    }
+    #[inline]
+    pub fn use_initial_rc_qp(mut self, use_initial_rc_qp: bool) -> Self {
+        self.inner.use_initial_rc_qp = use_initial_rc_qp.into();
+        self
+    }
+    #[inline]
+    pub fn initial_rc_qp(mut self, initial_rc_qp: VideoEncodeH265QpEXT) -> Self {
+        self.inner.initial_rc_qp = initial_rc_qp;
         self
     }
-    pub fn preceding_nalu_bytes(mut self, preceding_nalu_bytes: u32) -> Self {
-        self.inner.preceding_nalu_bytes = preceding_nalu_bytes;
+    #[inline]
+    pub fn use_min_qp(mut self, use_min_qp: bool) -> Self {
+        self.inner.use_min_qp = use_min_qp.into();
         self
     }
-    pub fn min_qp(mut self, min_qp: u8) -> Self {
+    #[inline]
+    pub fn min_qp(mut self, min_qp: VideoEncodeH265QpEXT) -> Self {
         self.inner.min_qp = min_qp;
         self
     }
-    pub fn max_qp(mut self, max_qp: u8) -> Self {
+    #[inline]
+    pub fn use_max_qp(mut self, use_max_qp: bool) -> Self {
+        self.inner.use_max_qp = use_max_qp.into();
+        self
+    }
+    #[inline]
+    pub fn max_qp(mut self, max_qp: VideoEncodeH265QpEXT) -> Self {
         self.inner.max_qp = max_qp;
         self
     }
+    #[inline]
+    pub fn use_max_frame_size(mut self, use_max_frame_size: bool) -> Self {
+        self.inner.use_max_frame_size = use_max_frame_size.into();
+        self
+    }
+    #[inline]
+    pub fn max_frame_size(mut self, max_frame_size: VideoEncodeH265FrameSizeEXT) -> Self {
+        self.inner.max_frame_size = max_frame_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH265RateControlLayerInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265ProfileInfoEXT.html>"]
+pub struct VideoEncodeH265ProfileInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub std_profile_idc: StdVideoH265ProfileIdc,
+}
+impl ::std::default::Default for VideoEncodeH265ProfileInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            std_profile_idc: StdVideoH265ProfileIdc::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH265ProfileInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_PROFILE_INFO_EXT;
+}
+impl VideoEncodeH265ProfileInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265ProfileInfoEXTBuilder<'a> {
+        VideoEncodeH265ProfileInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265ProfileInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265ProfileInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH265ProfileInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeH265ProfileInfoEXT {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileInfoEXTBuilder<'_> {}
+unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeH265ProfileInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH265ProfileInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265ProfileInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265ProfileInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265ProfileInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn std_profile_idc(mut self, std_profile_idc: StdVideoH265ProfileIdc) -> Self {
+        self.inner.std_profile_idc = std_profile_idc;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> VideoEncodeH265ProfileInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265DpbSlotInfoEXT.html>"]
+pub struct VideoEncodeH265DpbSlotInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub p_std_reference_info: *const StdVideoEncodeH265ReferenceInfo,
+}
+impl ::std::default::Default for VideoEncodeH265DpbSlotInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            p_std_reference_info: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for VideoEncodeH265DpbSlotInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT;
+}
+impl VideoEncodeH265DpbSlotInfoEXT {
+    pub fn builder<'a>() -> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
+        VideoEncodeH265DpbSlotInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
+    inner: VideoEncodeH265DpbSlotInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH265DpbSlotInfoEXTBuilder<'_> {}
+unsafe impl ExtendsVideoReferenceSlotInfoKHR for VideoEncodeH265DpbSlotInfoEXT {}
+impl<'a> ::std::ops::Deref for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
+    type Target = VideoEncodeH265DpbSlotInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> VideoEncodeH265DpbSlotInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn std_reference_info(
+        mut self,
+        std_reference_info: &'a StdVideoEncodeH265ReferenceInfo,
+    ) -> Self {
+        self.inner.p_std_reference_info = std_reference_info;
+        self
+    }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> VideoEncodeH264NaluSliceEXT {
+    pub fn build(self) -> VideoEncodeH265DpbSlotInfoEXT {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html>"]
 pub struct PhysicalDeviceInheritedViewportScissorFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub inherited_viewport_scissor2_d: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceInheritedViewportScissorFeaturesNV {
-    fn default() -> PhysicalDeviceInheritedViewportScissorFeaturesNV {
-        PhysicalDeviceInheritedViewportScissorFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             inherited_viewport_scissor2_d: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceInheritedViewportScissorFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV;
+}
 impl PhysicalDeviceInheritedViewportScissorFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
         PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder {
-            inner: PhysicalDeviceInheritedViewportScissorFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -49779,6 +60892,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceInheritedViewportScissorFeatures
     }
 }
 impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn inherited_viewport_scissor2_d(mut self, inherited_viewport_scissor2_d: bool) -> Self {
         self.inner.inherited_viewport_scissor2_d = inherited_viewport_scissor2_d.into();
         self
@@ -49791,8 +60905,9 @@ impl<'a> PhysicalDeviceInheritedViewportScissorFeaturesNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html>"]
 pub struct CommandBufferInheritanceViewportScissorInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -49801,9 +60916,10 @@ pub struct CommandBufferInheritanceViewportScissorInfoNV {
     pub p_viewport_depths: *const Viewport,
 }
 impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV {
-    fn default() -> CommandBufferInheritanceViewportScissorInfoNV {
-        CommandBufferInheritanceViewportScissorInfoNV {
-            s_type: StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             viewport_scissor2_d: Bool32::default(),
             viewport_depth_count: u32::default(),
@@ -49811,10 +60927,14 @@ impl ::std::default::Default for CommandBufferInheritanceViewportScissorInfoNV {
         }
     }
 }
+unsafe impl TaggedStructure for CommandBufferInheritanceViewportScissorInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV;
+}
 impl CommandBufferInheritanceViewportScissorInfoNV {
     pub fn builder<'a>() -> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
         CommandBufferInheritanceViewportScissorInfoNVBuilder {
-            inner: CommandBufferInheritanceViewportScissorInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -49841,14 +60961,17 @@ impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceViewportScissorInfoNVB
     }
 }
 impl<'a> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
+    #[inline]
     pub fn viewport_scissor2_d(mut self, viewport_scissor2_d: bool) -> Self {
         self.inner.viewport_scissor2_d = viewport_scissor2_d.into();
         self
     }
+    #[inline]
     pub fn viewport_depth_count(mut self, viewport_depth_count: u32) -> Self {
         self.inner.viewport_depth_count = viewport_depth_count;
         self
     }
+    #[inline]
     pub fn viewport_depths(mut self, viewport_depths: &'a Viewport) -> Self {
         self.inner.p_viewport_depths = viewport_depths;
         self
@@ -49861,26 +60984,32 @@ impl<'a> CommandBufferInheritanceViewportScissorInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html>"]
 pub struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub ycbcr2plane444_formats: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
-    fn default() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
-        PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             ycbcr2plane444_formats: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT;
+}
 impl PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
         PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder {
-            inner: PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -49909,6 +61038,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
     }
 }
 impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn ycbcr2plane444_formats(mut self, ycbcr2plane444_formats: bool) -> Self {
         self.inner.ycbcr2plane444_formats = ycbcr2plane444_formats.into();
         self
@@ -49921,8 +61051,9 @@ impl<'a> PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html>"]
 pub struct PhysicalDeviceProvokingVertexFeaturesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -49930,19 +61061,24 @@ pub struct PhysicalDeviceProvokingVertexFeaturesEXT {
     pub transform_feedback_preserves_provoking_vertex: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceProvokingVertexFeaturesEXT {
-    fn default() -> PhysicalDeviceProvokingVertexFeaturesEXT {
-        PhysicalDeviceProvokingVertexFeaturesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             provoking_vertex_last: Bool32::default(),
             transform_feedback_preserves_provoking_vertex: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceProvokingVertexFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
+}
 impl PhysicalDeviceProvokingVertexFeaturesEXT {
     pub fn builder<'a>() -> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
         PhysicalDeviceProvokingVertexFeaturesEXTBuilder {
-            inner: PhysicalDeviceProvokingVertexFeaturesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -49968,10 +61104,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexFeaturesEXTBuilde
     }
 }
 impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
+    #[inline]
     pub fn provoking_vertex_last(mut self, provoking_vertex_last: bool) -> Self {
         self.inner.provoking_vertex_last = provoking_vertex_last.into();
         self
     }
+    #[inline]
     pub fn transform_feedback_preserves_provoking_vertex(
         mut self,
         transform_feedback_preserves_provoking_vertex: bool,
@@ -49988,8 +61126,9 @@ impl<'a> PhysicalDeviceProvokingVertexFeaturesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html>"]
 pub struct PhysicalDeviceProvokingVertexPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -49997,19 +61136,24 @@ pub struct PhysicalDeviceProvokingVertexPropertiesEXT {
     pub transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceProvokingVertexPropertiesEXT {
-    fn default() -> PhysicalDeviceProvokingVertexPropertiesEXT {
-        PhysicalDeviceProvokingVertexPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             provoking_vertex_mode_per_pipeline: Bool32::default(),
             transform_feedback_preserves_triangle_fan_provoking_vertex: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceProvokingVertexPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT;
+}
 impl PhysicalDeviceProvokingVertexPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
         PhysicalDeviceProvokingVertexPropertiesEXTBuilder {
-            inner: PhysicalDeviceProvokingVertexPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -50036,6 +61180,7 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceProvokingVertexPropertiesEXTBuil
     }
 }
 impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn provoking_vertex_mode_per_pipeline(
         mut self,
         provoking_vertex_mode_per_pipeline: bool,
@@ -50043,6 +61188,7 @@ impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
         self.inner.provoking_vertex_mode_per_pipeline = provoking_vertex_mode_per_pipeline.into();
         self
     }
+    #[inline]
     pub fn transform_feedback_preserves_triangle_fan_provoking_vertex(
         mut self,
         transform_feedback_preserves_triangle_fan_provoking_vertex: bool,
@@ -50060,26 +61206,32 @@ impl<'a> PhysicalDeviceProvokingVertexPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.html>"]
 pub struct PipelineRasterizationProvokingVertexStateCreateInfoEXT {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub provoking_vertex_mode: ProvokingVertexModeEXT,
 }
 impl ::std::default::Default for PipelineRasterizationProvokingVertexStateCreateInfoEXT {
-    fn default() -> PipelineRasterizationProvokingVertexStateCreateInfoEXT {
-        PipelineRasterizationProvokingVertexStateCreateInfoEXT {
-            s_type: StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             provoking_vertex_mode: ProvokingVertexModeEXT::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PipelineRasterizationProvokingVertexStateCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT;
+}
 impl PipelineRasterizationProvokingVertexStateCreateInfoEXT {
     pub fn builder<'a>() -> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
         PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder {
-            inner: PipelineRasterizationProvokingVertexStateCreateInfoEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -50111,6 +61263,7 @@ impl<'a> ::std::ops::DerefMut
     }
 }
 impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
+    #[inline]
     pub fn provoking_vertex_mode(mut self, provoking_vertex_mode: ProvokingVertexModeEXT) -> Self {
         self.inner.provoking_vertex_mode = provoking_vertex_mode;
         self
@@ -50123,8 +61276,9 @@ impl<'a> PipelineRasterizationProvokingVertexStateCreateInfoEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCuModuleCreateInfoNVX.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuModuleCreateInfoNVX.html>"]
 pub struct CuModuleCreateInfoNVX {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -50132,19 +61286,23 @@ pub struct CuModuleCreateInfoNVX {
     pub p_data: *const c_void,
 }
 impl ::std::default::Default for CuModuleCreateInfoNVX {
-    fn default() -> CuModuleCreateInfoNVX {
-        CuModuleCreateInfoNVX {
-            s_type: StructureType::CU_MODULE_CREATE_INFO_NVX,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             data_size: usize::default(),
             p_data: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for CuModuleCreateInfoNVX {
+    const STRUCTURE_TYPE: StructureType = StructureType::CU_MODULE_CREATE_INFO_NVX;
+}
 impl CuModuleCreateInfoNVX {
     pub fn builder<'a>() -> CuModuleCreateInfoNVXBuilder<'a> {
         CuModuleCreateInfoNVXBuilder {
-            inner: CuModuleCreateInfoNVX::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -50166,12 +61324,10 @@ impl<'a> ::std::ops::DerefMut for CuModuleCreateInfoNVXBuilder<'a> {
     }
 }
 impl<'a> CuModuleCreateInfoNVXBuilder<'a> {
-    pub fn data_size(mut self, data_size: usize) -> Self {
-        self.inner.data_size = data_size;
-        self
-    }
-    pub fn data(mut self, data: *const c_void) -> Self {
-        self.inner.p_data = data;
+    #[inline]
+    pub fn data(mut self, data: &'a [u8]) -> Self {
+        self.inner.data_size = data.len();
+        self.inner.p_data = data.as_ptr().cast();
         self
     }
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
@@ -50182,8 +61338,9 @@ impl<'a> CuModuleCreateInfoNVXBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCuFunctionCreateInfoNVX.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuFunctionCreateInfoNVX.html>"]
 pub struct CuFunctionCreateInfoNVX {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -50191,19 +61348,23 @@ pub struct CuFunctionCreateInfoNVX {
     pub p_name: *const c_char,
 }
 impl ::std::default::Default for CuFunctionCreateInfoNVX {
-    fn default() -> CuFunctionCreateInfoNVX {
-        CuFunctionCreateInfoNVX {
-            s_type: StructureType::CU_FUNCTION_CREATE_INFO_NVX,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             module: CuModuleNVX::default(),
             p_name: ::std::ptr::null(),
         }
     }
 }
+unsafe impl TaggedStructure for CuFunctionCreateInfoNVX {
+    const STRUCTURE_TYPE: StructureType = StructureType::CU_FUNCTION_CREATE_INFO_NVX;
+}
 impl CuFunctionCreateInfoNVX {
     pub fn builder<'a>() -> CuFunctionCreateInfoNVXBuilder<'a> {
         CuFunctionCreateInfoNVXBuilder {
-            inner: CuFunctionCreateInfoNVX::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -50225,10 +61386,12 @@ impl<'a> ::std::ops::DerefMut for CuFunctionCreateInfoNVXBuilder<'a> {
     }
 }
 impl<'a> CuFunctionCreateInfoNVXBuilder<'a> {
+    #[inline]
     pub fn module(mut self, module: CuModuleNVX) -> Self {
         self.inner.module = module;
         self
     }
+    #[inline]
     pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
         self.inner.p_name = name.as_ptr();
         self
@@ -50241,8 +61404,9 @@ impl<'a> CuFunctionCreateInfoNVXBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCuLaunchInfoNVX.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCuLaunchInfoNVX.html>"]
 pub struct CuLaunchInfoNVX {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -50260,9 +61424,10 @@ pub struct CuLaunchInfoNVX {
     pub p_extras: *const *const c_void,
 }
 impl ::std::default::Default for CuLaunchInfoNVX {
-    fn default() -> CuLaunchInfoNVX {
-        CuLaunchInfoNVX {
-            s_type: StructureType::CU_LAUNCH_INFO_NVX,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             function: CuFunctionNVX::default(),
             grid_dim_x: u32::default(),
@@ -50279,10 +61444,13 @@ impl ::std::default::Default for CuLaunchInfoNVX {
         }
     }
 }
+unsafe impl TaggedStructure for CuLaunchInfoNVX {
+    const STRUCTURE_TYPE: StructureType = StructureType::CU_LAUNCH_INFO_NVX;
+}
 impl CuLaunchInfoNVX {
     pub fn builder<'a>() -> CuLaunchInfoNVXBuilder<'a> {
         CuLaunchInfoNVXBuilder {
-            inner: CuLaunchInfoNVX::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -50304,45 +61472,55 @@ impl<'a> ::std::ops::DerefMut for CuLaunchInfoNVXBuilder<'a> {
     }
 }
 impl<'a> CuLaunchInfoNVXBuilder<'a> {
+    #[inline]
     pub fn function(mut self, function: CuFunctionNVX) -> Self {
         self.inner.function = function;
         self
     }
+    #[inline]
     pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self {
         self.inner.grid_dim_x = grid_dim_x;
         self
     }
+    #[inline]
     pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self {
         self.inner.grid_dim_y = grid_dim_y;
         self
     }
+    #[inline]
     pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self {
         self.inner.grid_dim_z = grid_dim_z;
         self
     }
+    #[inline]
     pub fn block_dim_x(mut self, block_dim_x: u32) -> Self {
         self.inner.block_dim_x = block_dim_x;
         self
     }
+    #[inline]
     pub fn block_dim_y(mut self, block_dim_y: u32) -> Self {
         self.inner.block_dim_y = block_dim_y;
         self
     }
+    #[inline]
     pub fn block_dim_z(mut self, block_dim_z: u32) -> Self {
         self.inner.block_dim_z = block_dim_z;
         self
     }
+    #[inline]
     pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self {
         self.inner.shared_mem_bytes = shared_mem_bytes;
         self
     }
+    #[inline]
     pub fn params(mut self, params: &'a [*const c_void]) -> Self {
-        self.inner.param_count = params.len() as _;
+        self.inner.param_count = params.len();
         self.inner.p_params = params.as_ptr();
         self
     }
+    #[inline]
     pub fn extras(mut self, extras: &'a [*const c_void]) -> Self {
-        self.inner.extra_count = extras.len() as _;
+        self.inner.extra_count = extras.len();
         self.inner.p_extras = extras.as_ptr();
         self
     }
@@ -50354,57 +61532,1320 @@ impl<'a> CuLaunchInfoNVXBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR.html>"]
-pub struct PhysicalDeviceShaderIntegerDotProductFeaturesKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorBufferFeaturesEXT.html>"]
+pub struct PhysicalDeviceDescriptorBufferFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub descriptor_buffer: Bool32,
+    pub descriptor_buffer_capture_replay: Bool32,
+    pub descriptor_buffer_image_layout_ignored: Bool32,
+    pub descriptor_buffer_push_descriptors: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceDescriptorBufferFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            descriptor_buffer: Bool32::default(),
+            descriptor_buffer_capture_replay: Bool32::default(),
+            descriptor_buffer_image_layout_ignored: Bool32::default(),
+            descriptor_buffer_push_descriptors: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT;
+}
+impl PhysicalDeviceDescriptorBufferFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
+        PhysicalDeviceDescriptorBufferFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceDescriptorBufferFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorBufferFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceDescriptorBufferFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDescriptorBufferFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn descriptor_buffer(mut self, descriptor_buffer: bool) -> Self {
+        self.inner.descriptor_buffer = descriptor_buffer.into();
+        self
+    }
+    #[inline]
+    pub fn descriptor_buffer_capture_replay(
+        mut self,
+        descriptor_buffer_capture_replay: bool,
+    ) -> Self {
+        self.inner.descriptor_buffer_capture_replay = descriptor_buffer_capture_replay.into();
+        self
+    }
+    #[inline]
+    pub fn descriptor_buffer_image_layout_ignored(
+        mut self,
+        descriptor_buffer_image_layout_ignored: bool,
+    ) -> Self {
+        self.inner.descriptor_buffer_image_layout_ignored =
+            descriptor_buffer_image_layout_ignored.into();
+        self
+    }
+    #[inline]
+    pub fn descriptor_buffer_push_descriptors(
+        mut self,
+        descriptor_buffer_push_descriptors: bool,
+    ) -> Self {
+        self.inner.descriptor_buffer_push_descriptors = descriptor_buffer_push_descriptors.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDescriptorBufferFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorBufferPropertiesEXT.html>"]
+pub struct PhysicalDeviceDescriptorBufferPropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub combined_image_sampler_descriptor_single_array: Bool32,
+    pub bufferless_push_descriptors: Bool32,
+    pub allow_sampler_image_view_post_submit_creation: Bool32,
+    pub descriptor_buffer_offset_alignment: DeviceSize,
+    pub max_descriptor_buffer_bindings: u32,
+    pub max_resource_descriptor_buffer_bindings: u32,
+    pub max_sampler_descriptor_buffer_bindings: u32,
+    pub max_embedded_immutable_sampler_bindings: u32,
+    pub max_embedded_immutable_samplers: u32,
+    pub buffer_capture_replay_descriptor_data_size: usize,
+    pub image_capture_replay_descriptor_data_size: usize,
+    pub image_view_capture_replay_descriptor_data_size: usize,
+    pub sampler_capture_replay_descriptor_data_size: usize,
+    pub acceleration_structure_capture_replay_descriptor_data_size: usize,
+    pub sampler_descriptor_size: usize,
+    pub combined_image_sampler_descriptor_size: usize,
+    pub sampled_image_descriptor_size: usize,
+    pub storage_image_descriptor_size: usize,
+    pub uniform_texel_buffer_descriptor_size: usize,
+    pub robust_uniform_texel_buffer_descriptor_size: usize,
+    pub storage_texel_buffer_descriptor_size: usize,
+    pub robust_storage_texel_buffer_descriptor_size: usize,
+    pub uniform_buffer_descriptor_size: usize,
+    pub robust_uniform_buffer_descriptor_size: usize,
+    pub storage_buffer_descriptor_size: usize,
+    pub robust_storage_buffer_descriptor_size: usize,
+    pub input_attachment_descriptor_size: usize,
+    pub acceleration_structure_descriptor_size: usize,
+    pub max_sampler_descriptor_buffer_range: DeviceSize,
+    pub max_resource_descriptor_buffer_range: DeviceSize,
+    pub sampler_descriptor_buffer_address_space_size: DeviceSize,
+    pub resource_descriptor_buffer_address_space_size: DeviceSize,
+    pub descriptor_buffer_address_space_size: DeviceSize,
+}
+impl ::std::default::Default for PhysicalDeviceDescriptorBufferPropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            combined_image_sampler_descriptor_single_array: Bool32::default(),
+            bufferless_push_descriptors: Bool32::default(),
+            allow_sampler_image_view_post_submit_creation: Bool32::default(),
+            descriptor_buffer_offset_alignment: DeviceSize::default(),
+            max_descriptor_buffer_bindings: u32::default(),
+            max_resource_descriptor_buffer_bindings: u32::default(),
+            max_sampler_descriptor_buffer_bindings: u32::default(),
+            max_embedded_immutable_sampler_bindings: u32::default(),
+            max_embedded_immutable_samplers: u32::default(),
+            buffer_capture_replay_descriptor_data_size: usize::default(),
+            image_capture_replay_descriptor_data_size: usize::default(),
+            image_view_capture_replay_descriptor_data_size: usize::default(),
+            sampler_capture_replay_descriptor_data_size: usize::default(),
+            acceleration_structure_capture_replay_descriptor_data_size: usize::default(),
+            sampler_descriptor_size: usize::default(),
+            combined_image_sampler_descriptor_size: usize::default(),
+            sampled_image_descriptor_size: usize::default(),
+            storage_image_descriptor_size: usize::default(),
+            uniform_texel_buffer_descriptor_size: usize::default(),
+            robust_uniform_texel_buffer_descriptor_size: usize::default(),
+            storage_texel_buffer_descriptor_size: usize::default(),
+            robust_storage_texel_buffer_descriptor_size: usize::default(),
+            uniform_buffer_descriptor_size: usize::default(),
+            robust_uniform_buffer_descriptor_size: usize::default(),
+            storage_buffer_descriptor_size: usize::default(),
+            robust_storage_buffer_descriptor_size: usize::default(),
+            input_attachment_descriptor_size: usize::default(),
+            acceleration_structure_descriptor_size: usize::default(),
+            max_sampler_descriptor_buffer_range: DeviceSize::default(),
+            max_resource_descriptor_buffer_range: DeviceSize::default(),
+            sampler_descriptor_buffer_address_space_size: DeviceSize::default(),
+            resource_descriptor_buffer_address_space_size: DeviceSize::default(),
+            descriptor_buffer_address_space_size: DeviceSize::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT;
+}
+impl PhysicalDeviceDescriptorBufferPropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
+        PhysicalDeviceDescriptorBufferPropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
+    inner: PhysicalDeviceDescriptorBufferPropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorBufferPropertiesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
+    type Target = PhysicalDeviceDescriptorBufferPropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDescriptorBufferPropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn combined_image_sampler_descriptor_single_array(
+        mut self,
+        combined_image_sampler_descriptor_single_array: bool,
+    ) -> Self {
+        self.inner.combined_image_sampler_descriptor_single_array =
+            combined_image_sampler_descriptor_single_array.into();
+        self
+    }
+    #[inline]
+    pub fn bufferless_push_descriptors(mut self, bufferless_push_descriptors: bool) -> Self {
+        self.inner.bufferless_push_descriptors = bufferless_push_descriptors.into();
+        self
+    }
+    #[inline]
+    pub fn allow_sampler_image_view_post_submit_creation(
+        mut self,
+        allow_sampler_image_view_post_submit_creation: bool,
+    ) -> Self {
+        self.inner.allow_sampler_image_view_post_submit_creation =
+            allow_sampler_image_view_post_submit_creation.into();
+        self
+    }
+    #[inline]
+    pub fn descriptor_buffer_offset_alignment(
+        mut self,
+        descriptor_buffer_offset_alignment: DeviceSize,
+    ) -> Self {
+        self.inner.descriptor_buffer_offset_alignment = descriptor_buffer_offset_alignment;
+        self
+    }
+    #[inline]
+    pub fn max_descriptor_buffer_bindings(mut self, max_descriptor_buffer_bindings: u32) -> Self {
+        self.inner.max_descriptor_buffer_bindings = max_descriptor_buffer_bindings;
+        self
+    }
+    #[inline]
+    pub fn max_resource_descriptor_buffer_bindings(
+        mut self,
+        max_resource_descriptor_buffer_bindings: u32,
+    ) -> Self {
+        self.inner.max_resource_descriptor_buffer_bindings =
+            max_resource_descriptor_buffer_bindings;
+        self
+    }
+    #[inline]
+    pub fn max_sampler_descriptor_buffer_bindings(
+        mut self,
+        max_sampler_descriptor_buffer_bindings: u32,
+    ) -> Self {
+        self.inner.max_sampler_descriptor_buffer_bindings = max_sampler_descriptor_buffer_bindings;
+        self
+    }
+    #[inline]
+    pub fn max_embedded_immutable_sampler_bindings(
+        mut self,
+        max_embedded_immutable_sampler_bindings: u32,
+    ) -> Self {
+        self.inner.max_embedded_immutable_sampler_bindings =
+            max_embedded_immutable_sampler_bindings;
+        self
+    }
+    #[inline]
+    pub fn max_embedded_immutable_samplers(mut self, max_embedded_immutable_samplers: u32) -> Self {
+        self.inner.max_embedded_immutable_samplers = max_embedded_immutable_samplers;
+        self
+    }
+    #[inline]
+    pub fn buffer_capture_replay_descriptor_data_size(
+        mut self,
+        buffer_capture_replay_descriptor_data_size: usize,
+    ) -> Self {
+        self.inner.buffer_capture_replay_descriptor_data_size =
+            buffer_capture_replay_descriptor_data_size;
+        self
+    }
+    #[inline]
+    pub fn image_capture_replay_descriptor_data_size(
+        mut self,
+        image_capture_replay_descriptor_data_size: usize,
+    ) -> Self {
+        self.inner.image_capture_replay_descriptor_data_size =
+            image_capture_replay_descriptor_data_size;
+        self
+    }
+    #[inline]
+    pub fn image_view_capture_replay_descriptor_data_size(
+        mut self,
+        image_view_capture_replay_descriptor_data_size: usize,
+    ) -> Self {
+        self.inner.image_view_capture_replay_descriptor_data_size =
+            image_view_capture_replay_descriptor_data_size;
+        self
+    }
+    #[inline]
+    pub fn sampler_capture_replay_descriptor_data_size(
+        mut self,
+        sampler_capture_replay_descriptor_data_size: usize,
+    ) -> Self {
+        self.inner.sampler_capture_replay_descriptor_data_size =
+            sampler_capture_replay_descriptor_data_size;
+        self
+    }
+    #[inline]
+    pub fn acceleration_structure_capture_replay_descriptor_data_size(
+        mut self,
+        acceleration_structure_capture_replay_descriptor_data_size: usize,
+    ) -> Self {
+        self.inner
+            .acceleration_structure_capture_replay_descriptor_data_size =
+            acceleration_structure_capture_replay_descriptor_data_size;
+        self
+    }
+    #[inline]
+    pub fn sampler_descriptor_size(mut self, sampler_descriptor_size: usize) -> Self {
+        self.inner.sampler_descriptor_size = sampler_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn combined_image_sampler_descriptor_size(
+        mut self,
+        combined_image_sampler_descriptor_size: usize,
+    ) -> Self {
+        self.inner.combined_image_sampler_descriptor_size = combined_image_sampler_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn sampled_image_descriptor_size(mut self, sampled_image_descriptor_size: usize) -> Self {
+        self.inner.sampled_image_descriptor_size = sampled_image_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn storage_image_descriptor_size(mut self, storage_image_descriptor_size: usize) -> Self {
+        self.inner.storage_image_descriptor_size = storage_image_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn uniform_texel_buffer_descriptor_size(
+        mut self,
+        uniform_texel_buffer_descriptor_size: usize,
+    ) -> Self {
+        self.inner.uniform_texel_buffer_descriptor_size = uniform_texel_buffer_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn robust_uniform_texel_buffer_descriptor_size(
+        mut self,
+        robust_uniform_texel_buffer_descriptor_size: usize,
+    ) -> Self {
+        self.inner.robust_uniform_texel_buffer_descriptor_size =
+            robust_uniform_texel_buffer_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn storage_texel_buffer_descriptor_size(
+        mut self,
+        storage_texel_buffer_descriptor_size: usize,
+    ) -> Self {
+        self.inner.storage_texel_buffer_descriptor_size = storage_texel_buffer_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn robust_storage_texel_buffer_descriptor_size(
+        mut self,
+        robust_storage_texel_buffer_descriptor_size: usize,
+    ) -> Self {
+        self.inner.robust_storage_texel_buffer_descriptor_size =
+            robust_storage_texel_buffer_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn uniform_buffer_descriptor_size(mut self, uniform_buffer_descriptor_size: usize) -> Self {
+        self.inner.uniform_buffer_descriptor_size = uniform_buffer_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn robust_uniform_buffer_descriptor_size(
+        mut self,
+        robust_uniform_buffer_descriptor_size: usize,
+    ) -> Self {
+        self.inner.robust_uniform_buffer_descriptor_size = robust_uniform_buffer_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn storage_buffer_descriptor_size(mut self, storage_buffer_descriptor_size: usize) -> Self {
+        self.inner.storage_buffer_descriptor_size = storage_buffer_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn robust_storage_buffer_descriptor_size(
+        mut self,
+        robust_storage_buffer_descriptor_size: usize,
+    ) -> Self {
+        self.inner.robust_storage_buffer_descriptor_size = robust_storage_buffer_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn input_attachment_descriptor_size(
+        mut self,
+        input_attachment_descriptor_size: usize,
+    ) -> Self {
+        self.inner.input_attachment_descriptor_size = input_attachment_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn acceleration_structure_descriptor_size(
+        mut self,
+        acceleration_structure_descriptor_size: usize,
+    ) -> Self {
+        self.inner.acceleration_structure_descriptor_size = acceleration_structure_descriptor_size;
+        self
+    }
+    #[inline]
+    pub fn max_sampler_descriptor_buffer_range(
+        mut self,
+        max_sampler_descriptor_buffer_range: DeviceSize,
+    ) -> Self {
+        self.inner.max_sampler_descriptor_buffer_range = max_sampler_descriptor_buffer_range;
+        self
+    }
+    #[inline]
+    pub fn max_resource_descriptor_buffer_range(
+        mut self,
+        max_resource_descriptor_buffer_range: DeviceSize,
+    ) -> Self {
+        self.inner.max_resource_descriptor_buffer_range = max_resource_descriptor_buffer_range;
+        self
+    }
+    #[inline]
+    pub fn sampler_descriptor_buffer_address_space_size(
+        mut self,
+        sampler_descriptor_buffer_address_space_size: DeviceSize,
+    ) -> Self {
+        self.inner.sampler_descriptor_buffer_address_space_size =
+            sampler_descriptor_buffer_address_space_size;
+        self
+    }
+    #[inline]
+    pub fn resource_descriptor_buffer_address_space_size(
+        mut self,
+        resource_descriptor_buffer_address_space_size: DeviceSize,
+    ) -> Self {
+        self.inner.resource_descriptor_buffer_address_space_size =
+            resource_descriptor_buffer_address_space_size;
+        self
+    }
+    #[inline]
+    pub fn descriptor_buffer_address_space_size(
+        mut self,
+        descriptor_buffer_address_space_size: DeviceSize,
+    ) -> Self {
+        self.inner.descriptor_buffer_address_space_size = descriptor_buffer_address_space_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDescriptorBufferPropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.html>"]
+pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub combined_image_sampler_density_map_descriptor_size: usize,
+}
+impl ::std::default::Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            combined_image_sampler_density_map_descriptor_size: usize::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT;
+}
+impl PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
+        PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
+    inner: PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT
+{
+}
+impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
+    type Target = PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn combined_image_sampler_density_map_descriptor_size(
+        mut self,
+        combined_image_sampler_density_map_descriptor_size: usize,
+    ) -> Self {
+        self.inner
+            .combined_image_sampler_density_map_descriptor_size =
+            combined_image_sampler_density_map_descriptor_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorAddressInfoEXT.html>"]
+pub struct DescriptorAddressInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub address: DeviceAddress,
+    pub range: DeviceSize,
+    pub format: Format,
+}
+impl ::std::default::Default for DescriptorAddressInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            address: DeviceAddress::default(),
+            range: DeviceSize::default(),
+            format: Format::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DescriptorAddressInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_ADDRESS_INFO_EXT;
+}
+impl DescriptorAddressInfoEXT {
+    pub fn builder<'a>() -> DescriptorAddressInfoEXTBuilder<'a> {
+        DescriptorAddressInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DescriptorAddressInfoEXTBuilder<'a> {
+    inner: DescriptorAddressInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DescriptorAddressInfoEXTBuilder<'a> {
+    type Target = DescriptorAddressInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DescriptorAddressInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DescriptorAddressInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn address(mut self, address: DeviceAddress) -> Self {
+        self.inner.address = address;
+        self
+    }
+    #[inline]
+    pub fn range(mut self, range: DeviceSize) -> Self {
+        self.inner.range = range;
+        self
+    }
+    #[inline]
+    pub fn format(mut self, format: Format) -> Self {
+        self.inner.format = format;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DescriptorAddressInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferBindingInfoEXT.html>"]
+pub struct DescriptorBufferBindingInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub address: DeviceAddress,
+    pub usage: BufferUsageFlags,
+}
+impl ::std::default::Default for DescriptorBufferBindingInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            address: DeviceAddress::default(),
+            usage: BufferUsageFlags::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DescriptorBufferBindingInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_BUFFER_BINDING_INFO_EXT;
+}
+impl DescriptorBufferBindingInfoEXT {
+    pub fn builder<'a>() -> DescriptorBufferBindingInfoEXTBuilder<'a> {
+        DescriptorBufferBindingInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DescriptorBufferBindingInfoEXTBuilder<'a> {
+    inner: DescriptorBufferBindingInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+pub unsafe trait ExtendsDescriptorBufferBindingInfoEXT {}
+impl<'a> ::std::ops::Deref for DescriptorBufferBindingInfoEXTBuilder<'a> {
+    type Target = DescriptorBufferBindingInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DescriptorBufferBindingInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DescriptorBufferBindingInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn address(mut self, address: DeviceAddress) -> Self {
+        self.inner.address = address;
+        self
+    }
+    #[inline]
+    pub fn usage(mut self, usage: BufferUsageFlags) -> Self {
+        self.inner.usage = usage;
+        self
+    }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsDescriptorBufferBindingInfoEXT>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*mut T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DescriptorBufferBindingInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.html>"]
+pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub buffer: Buffer,
+}
+impl ::std::default::Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            buffer: Buffer::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DescriptorBufferBindingPushDescriptorBufferHandleEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT;
+}
+impl DescriptorBufferBindingPushDescriptorBufferHandleEXT {
+    pub fn builder<'a>() -> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
+        DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
+    inner: DescriptorBufferBindingPushDescriptorBufferHandleEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsDescriptorBufferBindingInfoEXT
+    for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDescriptorBufferBindingInfoEXT
+    for DescriptorBufferBindingPushDescriptorBufferHandleEXT
+{
+}
+impl<'a> ::std::ops::Deref for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
+    type Target = DescriptorBufferBindingPushDescriptorBufferHandleEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DescriptorBufferBindingPushDescriptorBufferHandleEXTBuilder<'a> {
+    #[inline]
+    pub fn buffer(mut self, buffer: Buffer) -> Self {
+        self.inner.buffer = buffer;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DescriptorBufferBindingPushDescriptorBufferHandleEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorDataEXT.html>"]
+pub union DescriptorDataEXT {
+    pub p_sampler: *const Sampler,
+    pub p_combined_image_sampler: *const DescriptorImageInfo,
+    pub p_input_attachment_image: *const DescriptorImageInfo,
+    pub p_sampled_image: *const DescriptorImageInfo,
+    pub p_storage_image: *const DescriptorImageInfo,
+    pub p_uniform_texel_buffer: *const DescriptorAddressInfoEXT,
+    pub p_storage_texel_buffer: *const DescriptorAddressInfoEXT,
+    pub p_uniform_buffer: *const DescriptorAddressInfoEXT,
+    pub p_storage_buffer: *const DescriptorAddressInfoEXT,
+    pub acceleration_structure: DeviceAddress,
+}
+impl ::std::default::Default for DescriptorDataEXT {
+    #[inline]
+    fn default() -> Self {
+        unsafe { ::std::mem::zeroed() }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorGetInfoEXT.html>"]
+pub struct DescriptorGetInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub ty: DescriptorType,
+    pub data: DescriptorDataEXT,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for DescriptorGetInfoEXT {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("DescriptorGetInfoEXT")
+            .field("s_type", &self.s_type)
+            .field("p_next", &self.p_next)
+            .field("ty", &self.ty)
+            .field("data", &"union")
+            .finish()
+    }
+}
+impl ::std::default::Default for DescriptorGetInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            ty: DescriptorType::default(),
+            data: DescriptorDataEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DescriptorGetInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_GET_INFO_EXT;
+}
+impl DescriptorGetInfoEXT {
+    pub fn builder<'a>() -> DescriptorGetInfoEXTBuilder<'a> {
+        DescriptorGetInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DescriptorGetInfoEXTBuilder<'a> {
+    inner: DescriptorGetInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DescriptorGetInfoEXTBuilder<'a> {
+    type Target = DescriptorGetInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DescriptorGetInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DescriptorGetInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn ty(mut self, ty: DescriptorType) -> Self {
+        self.inner.ty = ty;
+        self
+    }
+    #[inline]
+    pub fn data(mut self, data: DescriptorDataEXT) -> Self {
+        self.inner.data = data;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DescriptorGetInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCaptureDescriptorDataInfoEXT.html>"]
+pub struct BufferCaptureDescriptorDataInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub buffer: Buffer,
+}
+impl ::std::default::Default for BufferCaptureDescriptorDataInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            buffer: Buffer::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for BufferCaptureDescriptorDataInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+}
+impl BufferCaptureDescriptorDataInfoEXT {
+    pub fn builder<'a>() -> BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
+        BufferCaptureDescriptorDataInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
+    inner: BufferCaptureDescriptorDataInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
+    type Target = BufferCaptureDescriptorDataInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> BufferCaptureDescriptorDataInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn buffer(mut self, buffer: Buffer) -> Self {
+        self.inner.buffer = buffer;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> BufferCaptureDescriptorDataInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCaptureDescriptorDataInfoEXT.html>"]
+pub struct ImageCaptureDescriptorDataInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub image: Image,
+}
+impl ::std::default::Default for ImageCaptureDescriptorDataInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            image: Image::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageCaptureDescriptorDataInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+}
+impl ImageCaptureDescriptorDataInfoEXT {
+    pub fn builder<'a>() -> ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
+        ImageCaptureDescriptorDataInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
+    inner: ImageCaptureDescriptorDataInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
+    type Target = ImageCaptureDescriptorDataInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageCaptureDescriptorDataInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn image(mut self, image: Image) -> Self {
+        self.inner.image = image;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageCaptureDescriptorDataInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewCaptureDescriptorDataInfoEXT.html>"]
+pub struct ImageViewCaptureDescriptorDataInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub image_view: ImageView,
+}
+impl ::std::default::Default for ImageViewCaptureDescriptorDataInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            image_view: ImageView::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageViewCaptureDescriptorDataInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+}
+impl ImageViewCaptureDescriptorDataInfoEXT {
+    pub fn builder<'a>() -> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
+        ImageViewCaptureDescriptorDataInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
+    inner: ImageViewCaptureDescriptorDataInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
+    type Target = ImageViewCaptureDescriptorDataInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageViewCaptureDescriptorDataInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn image_view(mut self, image_view: ImageView) -> Self {
+        self.inner.image_view = image_view;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageViewCaptureDescriptorDataInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerCaptureDescriptorDataInfoEXT.html>"]
+pub struct SamplerCaptureDescriptorDataInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub sampler: Sampler,
+}
+impl ::std::default::Default for SamplerCaptureDescriptorDataInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            sampler: Sampler::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SamplerCaptureDescriptorDataInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+}
+impl SamplerCaptureDescriptorDataInfoEXT {
+    pub fn builder<'a>() -> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
+        SamplerCaptureDescriptorDataInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
+    inner: SamplerCaptureDescriptorDataInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
+    type Target = SamplerCaptureDescriptorDataInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SamplerCaptureDescriptorDataInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn sampler(mut self, sampler: Sampler) -> Self {
+        self.inner.sampler = sampler;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SamplerCaptureDescriptorDataInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCaptureDescriptorDataInfoEXT.html>"]
+pub struct AccelerationStructureCaptureDescriptorDataInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub acceleration_structure: AccelerationStructureKHR,
+    pub acceleration_structure_nv: AccelerationStructureNV,
+}
+impl ::std::default::Default for AccelerationStructureCaptureDescriptorDataInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            acceleration_structure: AccelerationStructureKHR::default(),
+            acceleration_structure_nv: AccelerationStructureNV::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for AccelerationStructureCaptureDescriptorDataInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT;
+}
+impl AccelerationStructureCaptureDescriptorDataInfoEXT {
+    pub fn builder<'a>() -> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
+        AccelerationStructureCaptureDescriptorDataInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
+    inner: AccelerationStructureCaptureDescriptorDataInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
+    type Target = AccelerationStructureCaptureDescriptorDataInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> AccelerationStructureCaptureDescriptorDataInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn acceleration_structure(
+        mut self,
+        acceleration_structure: AccelerationStructureKHR,
+    ) -> Self {
+        self.inner.acceleration_structure = acceleration_structure;
+        self
+    }
+    #[inline]
+    pub fn acceleration_structure_nv(
+        mut self,
+        acceleration_structure_nv: AccelerationStructureNV,
+    ) -> Self {
+        self.inner.acceleration_structure_nv = acceleration_structure_nv;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> AccelerationStructureCaptureDescriptorDataInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpaqueCaptureDescriptorDataCreateInfoEXT.html>"]
+pub struct OpaqueCaptureDescriptorDataCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub opaque_capture_descriptor_data: *const c_void,
+}
+impl ::std::default::Default for OpaqueCaptureDescriptorDataCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            opaque_capture_descriptor_data: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for OpaqueCaptureDescriptorDataCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT;
+}
+impl OpaqueCaptureDescriptorDataCreateInfoEXT {
+    pub fn builder<'a>() -> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
+        OpaqueCaptureDescriptorDataCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
+    inner: OpaqueCaptureDescriptorDataCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {}
+unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {}
+unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {}
+unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT {}
+unsafe impl ExtendsAccelerationStructureCreateInfoKHR
+    for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsAccelerationStructureCreateInfoKHR for OpaqueCaptureDescriptorDataCreateInfoEXT {}
+unsafe impl ExtendsAccelerationStructureCreateInfoNV
+    for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsAccelerationStructureCreateInfoNV for OpaqueCaptureDescriptorDataCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
+    type Target = OpaqueCaptureDescriptorDataCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> OpaqueCaptureDescriptorDataCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn opaque_capture_descriptor_data(
+        mut self,
+        opaque_capture_descriptor_data: *const c_void,
+    ) -> Self {
+        self.inner.opaque_capture_descriptor_data = opaque_capture_descriptor_data;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> OpaqueCaptureDescriptorDataCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductFeatures.html>"]
+pub struct PhysicalDeviceShaderIntegerDotProductFeatures {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub shader_integer_dot_product: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeaturesKHR {
-    fn default() -> PhysicalDeviceShaderIntegerDotProductFeaturesKHR {
-        PhysicalDeviceShaderIntegerDotProductFeaturesKHR {
-            s_type: StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR,
+impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             shader_integer_dot_product: Bool32::default(),
         }
     }
 }
-impl PhysicalDeviceShaderIntegerDotProductFeaturesKHR {
-    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesKHRBuilder<'a> {
-        PhysicalDeviceShaderIntegerDotProductFeaturesKHRBuilder {
-            inner: PhysicalDeviceShaderIntegerDotProductFeaturesKHR::default(),
+unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerDotProductFeatures {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
+}
+impl PhysicalDeviceShaderIntegerDotProductFeatures {
+    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
+        PhysicalDeviceShaderIntegerDotProductFeaturesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceShaderIntegerDotProductFeaturesKHRBuilder<'a> {
-    inner: PhysicalDeviceShaderIntegerDotProductFeaturesKHR,
+pub struct PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
+    inner: PhysicalDeviceShaderIntegerDotProductFeatures,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceFeatures2
-    for PhysicalDeviceShaderIntegerDotProductFeaturesKHRBuilder<'_>
-{
-}
-unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeaturesKHR {}
-unsafe impl ExtendsDeviceCreateInfo
-    for PhysicalDeviceShaderIntegerDotProductFeaturesKHRBuilder<'_>
+    for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_>
 {
 }
-unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeaturesKHR {}
-impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductFeaturesKHRBuilder<'a> {
-    type Target = PhysicalDeviceShaderIntegerDotProductFeaturesKHR;
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
+    type Target = PhysicalDeviceShaderIntegerDotProductFeatures;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductFeaturesKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesKHRBuilder<'a> {
+impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesBuilder<'a> {
+    #[inline]
     pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self {
         self.inner.shader_integer_dot_product = shader_integer_dot_product.into();
         self
@@ -50412,14 +62853,15 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductFeaturesKHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductFeaturesKHR {
+    pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductFeatures {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR.html>"]
-pub struct PhysicalDeviceShaderIntegerDotProductPropertiesKHR {
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderIntegerDotProductProperties.html>"]
+pub struct PhysicalDeviceShaderIntegerDotProductProperties {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
     pub integer_dot_product8_bit_unsigned_accelerated: Bool32,
@@ -50454,44 +62896,47 @@ pub struct PhysicalDeviceShaderIntegerDotProductPropertiesKHR {
     pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32,
     pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32,
 }
-impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductPropertiesKHR {
-    fn default() -> PhysicalDeviceShaderIntegerDotProductPropertiesKHR {
-        PhysicalDeviceShaderIntegerDotProductPropertiesKHR { s_type : StructureType :: PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () }
+impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductProperties {
+    #[inline]
+    fn default() -> Self {
+        Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () }
     }
 }
-impl PhysicalDeviceShaderIntegerDotProductPropertiesKHR {
-    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
-        PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder {
-            inner: PhysicalDeviceShaderIntegerDotProductPropertiesKHR::default(),
+unsafe impl TaggedStructure for PhysicalDeviceShaderIntegerDotProductProperties {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
+}
+impl PhysicalDeviceShaderIntegerDotProductProperties {
+    pub fn builder<'a>() -> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
+        PhysicalDeviceShaderIntegerDotProductPropertiesBuilder {
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
 }
 #[repr(transparent)]
-pub struct PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
-    inner: PhysicalDeviceShaderIntegerDotProductPropertiesKHR,
+pub struct PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
+    inner: PhysicalDeviceShaderIntegerDotProductProperties,
     marker: ::std::marker::PhantomData<&'a ()>,
 }
 unsafe impl ExtendsPhysicalDeviceProperties2
-    for PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'_>
+    for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'_>
 {
 }
-unsafe impl ExtendsPhysicalDeviceProperties2
-    for PhysicalDeviceShaderIntegerDotProductPropertiesKHR
-{
-}
-impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
-    type Target = PhysicalDeviceShaderIntegerDotProductPropertiesKHR;
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderIntegerDotProductProperties {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
+    type Target = PhysicalDeviceShaderIntegerDotProductProperties;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
-impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.inner
     }
 }
-impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
+impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesBuilder<'a> {
+    #[inline]
     pub fn integer_dot_product8_bit_unsigned_accelerated(
         mut self,
         integer_dot_product8_bit_unsigned_accelerated: bool,
@@ -50500,6 +62945,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product8_bit_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product8_bit_signed_accelerated(
         mut self,
         integer_dot_product8_bit_signed_accelerated: bool,
@@ -50508,6 +62954,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product8_bit_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product8_bit_mixed_signedness_accelerated(
         mut self,
         integer_dot_product8_bit_mixed_signedness_accelerated: bool,
@@ -50517,6 +62964,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product8_bit_mixed_signedness_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated(
         mut self,
         integer_dot_product4x8_bit_packed_unsigned_accelerated: bool,
@@ -50526,6 +62974,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product4x8_bit_packed_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product4x8_bit_packed_signed_accelerated(
         mut self,
         integer_dot_product4x8_bit_packed_signed_accelerated: bool,
@@ -50535,6 +62984,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product4x8_bit_packed_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated(
         mut self,
         integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool,
@@ -50544,6 +62994,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product16_bit_unsigned_accelerated(
         mut self,
         integer_dot_product16_bit_unsigned_accelerated: bool,
@@ -50552,6 +63003,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product16_bit_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product16_bit_signed_accelerated(
         mut self,
         integer_dot_product16_bit_signed_accelerated: bool,
@@ -50560,6 +63012,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product16_bit_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product16_bit_mixed_signedness_accelerated(
         mut self,
         integer_dot_product16_bit_mixed_signedness_accelerated: bool,
@@ -50569,6 +63022,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product16_bit_mixed_signedness_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product32_bit_unsigned_accelerated(
         mut self,
         integer_dot_product32_bit_unsigned_accelerated: bool,
@@ -50577,6 +63031,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product32_bit_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product32_bit_signed_accelerated(
         mut self,
         integer_dot_product32_bit_signed_accelerated: bool,
@@ -50585,6 +63040,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product32_bit_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product32_bit_mixed_signedness_accelerated(
         mut self,
         integer_dot_product32_bit_mixed_signedness_accelerated: bool,
@@ -50594,6 +63050,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product32_bit_mixed_signedness_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product64_bit_unsigned_accelerated(
         mut self,
         integer_dot_product64_bit_unsigned_accelerated: bool,
@@ -50602,6 +63059,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product64_bit_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product64_bit_signed_accelerated(
         mut self,
         integer_dot_product64_bit_signed_accelerated: bool,
@@ -50610,6 +63068,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product64_bit_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product64_bit_mixed_signedness_accelerated(
         mut self,
         integer_dot_product64_bit_mixed_signedness_accelerated: bool,
@@ -50619,6 +63078,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product64_bit_mixed_signedness_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool,
@@ -50628,6 +63088,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool,
@@ -50637,6 +63098,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool,
@@ -50646,6 +63108,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool,
@@ -50655,6 +63118,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool,
@@ -50664,6 +63128,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool,
@@ -50671,6 +63136,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
         self . inner . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ;
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool,
@@ -50680,6 +63146,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool,
@@ -50689,6 +63156,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool,
@@ -50698,6 +63166,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool,
@@ -50707,6 +63176,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool,
@@ -50716,6 +63186,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool,
@@ -50725,6 +63196,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool,
@@ -50734,6 +63206,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool,
@@ -50743,6 +63216,7 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
             integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into();
         self
     }
+    #[inline]
     pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated(
         mut self,
         integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool,
@@ -50755,13 +63229,14 @@ impl<'a> PhysicalDeviceShaderIntegerDotProductPropertiesKHRBuilder<'a> {
     #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
     #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
     #[doc = r" so references to builders can be passed directly to Vulkan functions."]
-    pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductPropertiesKHR {
+    pub fn build(self) -> PhysicalDeviceShaderIntegerDotProductProperties {
         self.inner
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDrmPropertiesEXT.html>"]
 pub struct PhysicalDeviceDrmPropertiesEXT {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -50773,9 +63248,10 @@ pub struct PhysicalDeviceDrmPropertiesEXT {
     pub render_minor: i64,
 }
 impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT {
-    fn default() -> PhysicalDeviceDrmPropertiesEXT {
-        PhysicalDeviceDrmPropertiesEXT {
-            s_type: StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             has_primary: Bool32::default(),
             has_render: Bool32::default(),
@@ -50786,10 +63262,13 @@ impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT {
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceDrmPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT;
+}
 impl PhysicalDeviceDrmPropertiesEXT {
     pub fn builder<'a>() -> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
         PhysicalDeviceDrmPropertiesEXTBuilder {
-            inner: PhysicalDeviceDrmPropertiesEXT::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -50813,26 +63292,32 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
     }
 }
 impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
+    #[inline]
     pub fn has_primary(mut self, has_primary: bool) -> Self {
         self.inner.has_primary = has_primary.into();
         self
     }
+    #[inline]
     pub fn has_render(mut self, has_render: bool) -> Self {
         self.inner.has_render = has_render.into();
         self
     }
+    #[inline]
     pub fn primary_major(mut self, primary_major: i64) -> Self {
         self.inner.primary_major = primary_major;
         self
     }
+    #[inline]
     pub fn primary_minor(mut self, primary_minor: i64) -> Self {
         self.inner.primary_minor = primary_minor;
         self
     }
+    #[inline]
     pub fn render_major(mut self, render_major: i64) -> Self {
         self.inner.render_major = render_major;
         self
     }
+    #[inline]
     pub fn render_minor(mut self, render_minor: i64) -> Self {
         self.inner.render_minor = render_minor;
         self
@@ -50845,8 +63330,152 @@ impl<'a> PhysicalDeviceDrmPropertiesEXTBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.html>"]
+pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub fragment_shader_barycentric: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            fragment_shader_barycentric: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
+}
+impl PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
+    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
+        PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
+    inner: PhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
+    type Target = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesKHRBuilder<'a> {
+    #[inline]
+    pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self {
+        self.inner.fragment_shader_barycentric = fragment_shader_barycentric.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.html>"]
+pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub tri_strip_vertex_order_independent_of_provoking_vertex: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            tri_strip_vertex_order_independent_of_provoking_vertex: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR;
+}
+impl PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
+    pub fn builder<'a>() -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
+        PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
+    inner: PhysicalDeviceFragmentShaderBarycentricPropertiesKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR
+{
+}
+impl<'a> ::std::ops::Deref for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
+    type Target = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceFragmentShaderBarycentricPropertiesKHRBuilder<'a> {
+    #[inline]
+    pub fn tri_strip_vertex_order_independent_of_provoking_vertex(
+        mut self,
+        tri_strip_vertex_order_independent_of_provoking_vertex: bool,
+    ) -> Self {
+        self.inner
+            .tri_strip_vertex_order_independent_of_provoking_vertex =
+            tri_strip_vertex_order_independent_of_provoking_vertex.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html>"]
 pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV {
     pub s_type: StructureType,
     pub p_next: *mut c_void,
@@ -50854,19 +63483,24 @@ pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV {
     pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32,
 }
 impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV {
-    fn default() -> PhysicalDeviceRayTracingMotionBlurFeaturesNV {
-        PhysicalDeviceRayTracingMotionBlurFeaturesNV {
-            s_type: StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null_mut(),
             ray_tracing_motion_blur: Bool32::default(),
             ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(),
         }
     }
 }
+unsafe impl TaggedStructure for PhysicalDeviceRayTracingMotionBlurFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV;
+}
 impl PhysicalDeviceRayTracingMotionBlurFeaturesNV {
     pub fn builder<'a>() -> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
         PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder {
-            inner: PhysicalDeviceRayTracingMotionBlurFeaturesNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -50895,10 +63529,12 @@ impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingMotionBlurFeaturesNVBu
     }
 }
 impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
+    #[inline]
     pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self {
         self.inner.ray_tracing_motion_blur = ray_tracing_motion_blur.into();
         self
     }
+    #[inline]
     pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect(
         mut self,
         ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool,
@@ -50917,12 +63553,13 @@ impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNVBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html>"]
 pub struct AccelerationStructureGeometryMotionTrianglesDataNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
     pub vertex_data: DeviceOrHostAddressConstKHR,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("AccelerationStructureGeometryMotionTrianglesDataNV")
@@ -50933,18 +63570,23 @@ impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV {
     }
 }
 impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV {
-    fn default() -> AccelerationStructureGeometryMotionTrianglesDataNV {
-        AccelerationStructureGeometryMotionTrianglesDataNV {
-            s_type: StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             vertex_data: DeviceOrHostAddressConstKHR::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureGeometryMotionTrianglesDataNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV;
+}
 impl AccelerationStructureGeometryMotionTrianglesDataNV {
     pub fn builder<'a>() -> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
         AccelerationStructureGeometryMotionTrianglesDataNVBuilder {
-            inner: AccelerationStructureGeometryMotionTrianglesDataNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -50974,6 +63616,7 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureGeometryMotionTrianglesDa
     }
 }
 impl<'a> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
+    #[inline]
     pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self {
         self.inner.vertex_data = vertex_data;
         self
@@ -50986,8 +63629,9 @@ impl<'a> AccelerationStructureGeometryMotionTrianglesDataNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInfoNV.html>"]
 pub struct AccelerationStructureMotionInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -50995,19 +63639,23 @@ pub struct AccelerationStructureMotionInfoNV {
     pub flags: AccelerationStructureMotionInfoFlagsNV,
 }
 impl ::std::default::Default for AccelerationStructureMotionInfoNV {
-    fn default() -> AccelerationStructureMotionInfoNV {
-        AccelerationStructureMotionInfoNV {
-            s_type: StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             max_instances: u32::default(),
             flags: AccelerationStructureMotionInfoFlagsNV::default(),
         }
     }
 }
+unsafe impl TaggedStructure for AccelerationStructureMotionInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV;
+}
 impl AccelerationStructureMotionInfoNV {
     pub fn builder<'a>() -> AccelerationStructureMotionInfoNVBuilder<'a> {
         AccelerationStructureMotionInfoNVBuilder {
-            inner: AccelerationStructureMotionInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -51034,10 +63682,12 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInfoNVBuilder<'a> {
     }
 }
 impl<'a> AccelerationStructureMotionInfoNVBuilder<'a> {
+    #[inline]
     pub fn max_instances(mut self, max_instances: u32) -> Self {
         self.inner.max_instances = max_instances;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self {
         self.inner.flags = flags;
         self
@@ -51050,8 +63700,9 @@ impl<'a> AccelerationStructureMotionInfoNVBuilder<'a> {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone, Default, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSRTDataNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSRTDataNV.html>"]
 pub struct SRTDataNV {
     pub sx: f32,
     pub a: f32,
@@ -51073,7 +63724,7 @@ pub struct SRTDataNV {
 impl SRTDataNV {
     pub fn builder<'a>() -> SRTDataNVBuilder<'a> {
         SRTDataNVBuilder {
-            inner: SRTDataNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -51095,66 +63746,82 @@ impl<'a> ::std::ops::DerefMut for SRTDataNVBuilder<'a> {
     }
 }
 impl<'a> SRTDataNVBuilder<'a> {
+    #[inline]
     pub fn sx(mut self, sx: f32) -> Self {
         self.inner.sx = sx;
         self
     }
+    #[inline]
     pub fn a(mut self, a: f32) -> Self {
         self.inner.a = a;
         self
     }
+    #[inline]
     pub fn b(mut self, b: f32) -> Self {
         self.inner.b = b;
         self
     }
+    #[inline]
     pub fn pvx(mut self, pvx: f32) -> Self {
         self.inner.pvx = pvx;
         self
     }
+    #[inline]
     pub fn sy(mut self, sy: f32) -> Self {
         self.inner.sy = sy;
         self
     }
+    #[inline]
     pub fn c(mut self, c: f32) -> Self {
         self.inner.c = c;
         self
     }
+    #[inline]
     pub fn pvy(mut self, pvy: f32) -> Self {
         self.inner.pvy = pvy;
         self
     }
+    #[inline]
     pub fn sz(mut self, sz: f32) -> Self {
         self.inner.sz = sz;
         self
     }
+    #[inline]
     pub fn pvz(mut self, pvz: f32) -> Self {
         self.inner.pvz = pvz;
         self
     }
+    #[inline]
     pub fn qx(mut self, qx: f32) -> Self {
         self.inner.qx = qx;
         self
     }
+    #[inline]
     pub fn qy(mut self, qy: f32) -> Self {
         self.inner.qy = qy;
         self
     }
+    #[inline]
     pub fn qz(mut self, qz: f32) -> Self {
         self.inner.qz = qz;
         self
     }
+    #[inline]
     pub fn qw(mut self, qw: f32) -> Self {
         self.inner.qw = qw;
         self
     }
+    #[inline]
     pub fn tx(mut self, tx: f32) -> Self {
         self.inner.tx = tx;
         self
     }
+    #[inline]
     pub fn ty(mut self, ty: f32) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn tz(mut self, tz: f32) -> Self {
         self.inner.tz = tz;
         self
@@ -51168,45 +63835,51 @@ impl<'a> SRTDataNVBuilder<'a> {
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureSRTMotionInstanceNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureSRTMotionInstanceNV.html>"]
 pub struct AccelerationStructureSRTMotionInstanceNV {
     pub transform_t0: SRTDataNV,
     pub transform_t1: SRTDataNV,
-    pub instance_custom_index_and_mask: u32,
-    pub instance_shader_binding_table_record_offset_and_flags: u32,
+    #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
+    pub instance_custom_index_and_mask: Packed24_8,
+    #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
+    pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
     pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/AccelerationStructureMatrixMotionInstanceNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/AccelerationStructureMatrixMotionInstanceNV.html>"]
 pub struct AccelerationStructureMatrixMotionInstanceNV {
     pub transform_t0: TransformMatrixKHR,
     pub transform_t1: TransformMatrixKHR,
-    pub instance_custom_index_and_mask: u32,
-    pub instance_shader_binding_table_record_offset_and_flags: u32,
+    #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"]
+    pub instance_custom_index_and_mask: Packed24_8,
+    #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"]
+    pub instance_shader_binding_table_record_offset_and_flags: Packed24_8,
     pub acceleration_structure_reference: AccelerationStructureReferenceKHR,
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInstanceDataNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceDataNV.html>"]
 pub union AccelerationStructureMotionInstanceDataNV {
     pub static_instance: AccelerationStructureInstanceKHR,
     pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV,
     pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV,
 }
 impl ::std::default::Default for AccelerationStructureMotionInstanceDataNV {
-    fn default() -> AccelerationStructureMotionInstanceDataNV {
+    #[inline]
+    fn default() -> Self {
         unsafe { ::std::mem::zeroed() }
     }
 }
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInstanceNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceNV.html>"]
 pub struct AccelerationStructureMotionInstanceNV {
     pub ty: AccelerationStructureMotionInstanceTypeNV,
     pub flags: AccelerationStructureMotionInstanceFlagsNV,
     pub data: AccelerationStructureMotionInstanceDataNV,
 }
+#[cfg(feature = "debug")]
 impl fmt::Debug for AccelerationStructureMotionInstanceNV {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("AccelerationStructureMotionInstanceNV")
@@ -51219,7 +63892,7 @@ impl fmt::Debug for AccelerationStructureMotionInstanceNV {
 impl AccelerationStructureMotionInstanceNV {
     pub fn builder<'a>() -> AccelerationStructureMotionInstanceNVBuilder<'a> {
         AccelerationStructureMotionInstanceNVBuilder {
-            inner: AccelerationStructureMotionInstanceNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -51241,14 +63914,17 @@ impl<'a> ::std::ops::DerefMut for AccelerationStructureMotionInstanceNVBuilder<'
     }
 }
 impl<'a> AccelerationStructureMotionInstanceNVBuilder<'a> {
+    #[inline]
     pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self {
         self.inner.ty = ty;
         self
     }
+    #[inline]
     pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self {
         self.inner.flags = flags;
         self
     }
+    #[inline]
     pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self {
         self.inner.data = data;
         self
@@ -51260,11 +63936,12 @@ impl<'a> AccelerationStructureMotionInstanceNVBuilder<'a> {
         self.inner
     }
 }
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRemoteAddressNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRemoteAddressNV.html>"]
 pub type RemoteAddressNV = c_void;
 #[repr(C)]
-#[derive(Copy, Clone, Debug)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryGetRemoteAddressInfoNV.html>"]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryGetRemoteAddressInfoNV.html>"]
 pub struct MemoryGetRemoteAddressInfoNV {
     pub s_type: StructureType,
     pub p_next: *const c_void,
@@ -51272,19 +63949,23 @@ pub struct MemoryGetRemoteAddressInfoNV {
     pub handle_type: ExternalMemoryHandleTypeFlags,
 }
 impl ::std::default::Default for MemoryGetRemoteAddressInfoNV {
-    fn default() -> MemoryGetRemoteAddressInfoNV {
-        MemoryGetRemoteAddressInfoNV {
-            s_type: StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV,
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
             p_next: ::std::ptr::null(),
             memory: DeviceMemory::default(),
             handle_type: ExternalMemoryHandleTypeFlags::default(),
         }
     }
 }
+unsafe impl TaggedStructure for MemoryGetRemoteAddressInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV;
+}
 impl MemoryGetRemoteAddressInfoNV {
     pub fn builder<'a>() -> MemoryGetRemoteAddressInfoNVBuilder<'a> {
         MemoryGetRemoteAddressInfoNVBuilder {
-            inner: MemoryGetRemoteAddressInfoNV::default(),
+            inner: Self::default(),
             marker: ::std::marker::PhantomData,
         }
     }
@@ -51306,10 +63987,12 @@ impl<'a> ::std::ops::DerefMut for MemoryGetRemoteAddressInfoNVBuilder<'a> {
     }
 }
 impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> {
+    #[inline]
     pub fn memory(mut self, memory: DeviceMemory) -> Self {
         self.inner.memory = memory;
         self
     }
+    #[inline]
     pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self {
         self.inner.handle_type = handle_type;
         self
@@ -51321,3 +64004,10745 @@ impl<'a> MemoryGetRemoteAddressInfoNVBuilder<'a> {
         self.inner
     }
 }
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMemoryBufferCollectionFUCHSIA.html>"]
+pub struct ImportMemoryBufferCollectionFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub collection: BufferCollectionFUCHSIA,
+    pub index: u32,
+}
+impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            collection: BufferCollectionFUCHSIA::default(),
+            index: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImportMemoryBufferCollectionFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA;
+}
+impl ImportMemoryBufferCollectionFUCHSIA {
+    pub fn builder<'a>() -> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
+        ImportMemoryBufferCollectionFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
+    inner: ImportMemoryBufferCollectionFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIABuilder<'_> {}
+unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA {}
+impl<'a> ::std::ops::Deref for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
+    type Target = ImportMemoryBufferCollectionFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImportMemoryBufferCollectionFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
+        self.inner.collection = collection;
+        self
+    }
+    #[inline]
+    pub fn index(mut self, index: u32) -> Self {
+        self.inner.index = index;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImportMemoryBufferCollectionFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionImageCreateInfoFUCHSIA.html>"]
+pub struct BufferCollectionImageCreateInfoFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub collection: BufferCollectionFUCHSIA,
+    pub index: u32,
+}
+impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            collection: BufferCollectionFUCHSIA::default(),
+            index: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for BufferCollectionImageCreateInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA;
+}
+impl BufferCollectionImageCreateInfoFUCHSIA {
+    pub fn builder<'a>() -> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
+        BufferCollectionImageCreateInfoFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
+    inner: BufferCollectionImageCreateInfoFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIABuilder<'_> {}
+unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA {}
+impl<'a> ::std::ops::Deref for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
+    type Target = BufferCollectionImageCreateInfoFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> BufferCollectionImageCreateInfoFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
+        self.inner.collection = collection;
+        self
+    }
+    #[inline]
+    pub fn index(mut self, index: u32) -> Self {
+        self.inner.index = index;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> BufferCollectionImageCreateInfoFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionBufferCreateInfoFUCHSIA.html>"]
+pub struct BufferCollectionBufferCreateInfoFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub collection: BufferCollectionFUCHSIA,
+    pub index: u32,
+}
+impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            collection: BufferCollectionFUCHSIA::default(),
+            index: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for BufferCollectionBufferCreateInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA;
+}
+impl BufferCollectionBufferCreateInfoFUCHSIA {
+    pub fn builder<'a>() -> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
+        BufferCollectionBufferCreateInfoFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
+    inner: BufferCollectionBufferCreateInfoFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIABuilder<'_> {}
+unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA {}
+impl<'a> ::std::ops::Deref for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
+    type Target = BufferCollectionBufferCreateInfoFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> BufferCollectionBufferCreateInfoFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self {
+        self.inner.collection = collection;
+        self
+    }
+    #[inline]
+    pub fn index(mut self, index: u32) -> Self {
+        self.inner.index = index;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> BufferCollectionBufferCreateInfoFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionCreateInfoFUCHSIA.html>"]
+pub struct BufferCollectionCreateInfoFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub collection_token: zx_handle_t,
+}
+impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            collection_token: zx_handle_t::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for BufferCollectionCreateInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA;
+}
+impl BufferCollectionCreateInfoFUCHSIA {
+    pub fn builder<'a>() -> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
+        BufferCollectionCreateInfoFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct BufferCollectionCreateInfoFUCHSIABuilder<'a> {
+    inner: BufferCollectionCreateInfoFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
+    type Target = BufferCollectionCreateInfoFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for BufferCollectionCreateInfoFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> BufferCollectionCreateInfoFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self {
+        self.inner.collection_token = collection_token;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> BufferCollectionCreateInfoFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionPropertiesFUCHSIA.html>"]
+pub struct BufferCollectionPropertiesFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub memory_type_bits: u32,
+    pub buffer_count: u32,
+    pub create_info_index: u32,
+    pub sysmem_pixel_format: u64,
+    pub format_features: FormatFeatureFlags,
+    pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA,
+    pub sampler_ycbcr_conversion_components: ComponentMapping,
+    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
+    pub suggested_ycbcr_range: SamplerYcbcrRange,
+    pub suggested_x_chroma_offset: ChromaLocation,
+    pub suggested_y_chroma_offset: ChromaLocation,
+}
+impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            memory_type_bits: u32::default(),
+            buffer_count: u32::default(),
+            create_info_index: u32::default(),
+            sysmem_pixel_format: u64::default(),
+            format_features: FormatFeatureFlags::default(),
+            sysmem_color_space_index: SysmemColorSpaceFUCHSIA::default(),
+            sampler_ycbcr_conversion_components: ComponentMapping::default(),
+            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
+            suggested_ycbcr_range: SamplerYcbcrRange::default(),
+            suggested_x_chroma_offset: ChromaLocation::default(),
+            suggested_y_chroma_offset: ChromaLocation::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for BufferCollectionPropertiesFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA;
+}
+impl BufferCollectionPropertiesFUCHSIA {
+    pub fn builder<'a>() -> BufferCollectionPropertiesFUCHSIABuilder<'a> {
+        BufferCollectionPropertiesFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct BufferCollectionPropertiesFUCHSIABuilder<'a> {
+    inner: BufferCollectionPropertiesFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for BufferCollectionPropertiesFUCHSIABuilder<'a> {
+    type Target = BufferCollectionPropertiesFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for BufferCollectionPropertiesFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> BufferCollectionPropertiesFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self {
+        self.inner.memory_type_bits = memory_type_bits;
+        self
+    }
+    #[inline]
+    pub fn buffer_count(mut self, buffer_count: u32) -> Self {
+        self.inner.buffer_count = buffer_count;
+        self
+    }
+    #[inline]
+    pub fn create_info_index(mut self, create_info_index: u32) -> Self {
+        self.inner.create_info_index = create_info_index;
+        self
+    }
+    #[inline]
+    pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self {
+        self.inner.sysmem_pixel_format = sysmem_pixel_format;
+        self
+    }
+    #[inline]
+    pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self {
+        self.inner.format_features = format_features;
+        self
+    }
+    #[inline]
+    pub fn sysmem_color_space_index(
+        mut self,
+        sysmem_color_space_index: SysmemColorSpaceFUCHSIA,
+    ) -> Self {
+        self.inner.sysmem_color_space_index = sysmem_color_space_index;
+        self
+    }
+    #[inline]
+    pub fn sampler_ycbcr_conversion_components(
+        mut self,
+        sampler_ycbcr_conversion_components: ComponentMapping,
+    ) -> Self {
+        self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
+        self
+    }
+    #[inline]
+    pub fn suggested_ycbcr_model(
+        mut self,
+        suggested_ycbcr_model: SamplerYcbcrModelConversion,
+    ) -> Self {
+        self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
+        self
+    }
+    #[inline]
+    pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
+        self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
+        self
+    }
+    #[inline]
+    pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
+        self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
+        self
+    }
+    #[inline]
+    pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
+        self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> BufferCollectionPropertiesFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferConstraintsInfoFUCHSIA.html>"]
+pub struct BufferConstraintsInfoFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub create_info: BufferCreateInfo,
+    pub required_format_features: FormatFeatureFlags,
+    pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
+}
+impl ::std::default::Default for BufferConstraintsInfoFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            create_info: BufferCreateInfo::default(),
+            required_format_features: FormatFeatureFlags::default(),
+            buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for BufferConstraintsInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA;
+}
+impl BufferConstraintsInfoFUCHSIA {
+    pub fn builder<'a>() -> BufferConstraintsInfoFUCHSIABuilder<'a> {
+        BufferConstraintsInfoFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct BufferConstraintsInfoFUCHSIABuilder<'a> {
+    inner: BufferConstraintsInfoFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for BufferConstraintsInfoFUCHSIABuilder<'a> {
+    type Target = BufferConstraintsInfoFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for BufferConstraintsInfoFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> BufferConstraintsInfoFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn create_info(mut self, create_info: BufferCreateInfo) -> Self {
+        self.inner.create_info = create_info;
+        self
+    }
+    #[inline]
+    pub fn required_format_features(
+        mut self,
+        required_format_features: FormatFeatureFlags,
+    ) -> Self {
+        self.inner.required_format_features = required_format_features;
+        self
+    }
+    #[inline]
+    pub fn buffer_collection_constraints(
+        mut self,
+        buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
+    ) -> Self {
+        self.inner.buffer_collection_constraints = buffer_collection_constraints;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> BufferConstraintsInfoFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSysmemColorSpaceFUCHSIA.html>"]
+pub struct SysmemColorSpaceFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub color_space: u32,
+}
+impl ::std::default::Default for SysmemColorSpaceFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            color_space: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SysmemColorSpaceFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::SYSMEM_COLOR_SPACE_FUCHSIA;
+}
+impl SysmemColorSpaceFUCHSIA {
+    pub fn builder<'a>() -> SysmemColorSpaceFUCHSIABuilder<'a> {
+        SysmemColorSpaceFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SysmemColorSpaceFUCHSIABuilder<'a> {
+    inner: SysmemColorSpaceFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for SysmemColorSpaceFUCHSIABuilder<'a> {
+    type Target = SysmemColorSpaceFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SysmemColorSpaceFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SysmemColorSpaceFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn color_space(mut self, color_space: u32) -> Self {
+        self.inner.color_space = color_space;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SysmemColorSpaceFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageFormatConstraintsInfoFUCHSIA.html>"]
+pub struct ImageFormatConstraintsInfoFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub image_create_info: ImageCreateInfo,
+    pub required_format_features: FormatFeatureFlags,
+    pub flags: ImageFormatConstraintsFlagsFUCHSIA,
+    pub sysmem_pixel_format: u64,
+    pub color_space_count: u32,
+    pub p_color_spaces: *const SysmemColorSpaceFUCHSIA,
+}
+impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            image_create_info: ImageCreateInfo::default(),
+            required_format_features: FormatFeatureFlags::default(),
+            flags: ImageFormatConstraintsFlagsFUCHSIA::default(),
+            sysmem_pixel_format: u64::default(),
+            color_space_count: u32::default(),
+            p_color_spaces: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageFormatConstraintsInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA;
+}
+impl ImageFormatConstraintsInfoFUCHSIA {
+    pub fn builder<'a>() -> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
+        ImageFormatConstraintsInfoFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
+    inner: ImageFormatConstraintsInfoFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
+    type Target = ImageFormatConstraintsInfoFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageFormatConstraintsInfoFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn image_create_info(mut self, image_create_info: ImageCreateInfo) -> Self {
+        self.inner.image_create_info = image_create_info;
+        self
+    }
+    #[inline]
+    pub fn required_format_features(
+        mut self,
+        required_format_features: FormatFeatureFlags,
+    ) -> Self {
+        self.inner.required_format_features = required_format_features;
+        self
+    }
+    #[inline]
+    pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self {
+        self.inner.sysmem_pixel_format = sysmem_pixel_format;
+        self
+    }
+    #[inline]
+    pub fn color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self {
+        self.inner.color_space_count = color_spaces.len() as _;
+        self.inner.p_color_spaces = color_spaces.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageFormatConstraintsInfoFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageConstraintsInfoFUCHSIA.html>"]
+pub struct ImageConstraintsInfoFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub format_constraints_count: u32,
+    pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA,
+    pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
+    pub flags: ImageConstraintsInfoFlagsFUCHSIA,
+}
+impl ::std::default::Default for ImageConstraintsInfoFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            format_constraints_count: u32::default(),
+            p_format_constraints: ::std::ptr::null(),
+            buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(),
+            flags: ImageConstraintsInfoFlagsFUCHSIA::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageConstraintsInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA;
+}
+impl ImageConstraintsInfoFUCHSIA {
+    pub fn builder<'a>() -> ImageConstraintsInfoFUCHSIABuilder<'a> {
+        ImageConstraintsInfoFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageConstraintsInfoFUCHSIABuilder<'a> {
+    inner: ImageConstraintsInfoFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for ImageConstraintsInfoFUCHSIABuilder<'a> {
+    type Target = ImageConstraintsInfoFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageConstraintsInfoFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageConstraintsInfoFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn format_constraints(
+        mut self,
+        format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA],
+    ) -> Self {
+        self.inner.format_constraints_count = format_constraints.len() as _;
+        self.inner.p_format_constraints = format_constraints.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn buffer_collection_constraints(
+        mut self,
+        buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA,
+    ) -> Self {
+        self.inner.buffer_collection_constraints = buffer_collection_constraints;
+        self
+    }
+    #[inline]
+    pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageConstraintsInfoFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBufferCollectionConstraintsInfoFUCHSIA.html>"]
+pub struct BufferCollectionConstraintsInfoFUCHSIA {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub min_buffer_count: u32,
+    pub max_buffer_count: u32,
+    pub min_buffer_count_for_camping: u32,
+    pub min_buffer_count_for_dedicated_slack: u32,
+    pub min_buffer_count_for_shared_slack: u32,
+}
+impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            min_buffer_count: u32::default(),
+            max_buffer_count: u32::default(),
+            min_buffer_count_for_camping: u32::default(),
+            min_buffer_count_for_dedicated_slack: u32::default(),
+            min_buffer_count_for_shared_slack: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for BufferCollectionConstraintsInfoFUCHSIA {
+    const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA;
+}
+impl BufferCollectionConstraintsInfoFUCHSIA {
+    pub fn builder<'a>() -> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
+        BufferCollectionConstraintsInfoFUCHSIABuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
+    inner: BufferCollectionConstraintsInfoFUCHSIA,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
+    type Target = BufferCollectionConstraintsInfoFUCHSIA;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> BufferCollectionConstraintsInfoFUCHSIABuilder<'a> {
+    #[inline]
+    pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self {
+        self.inner.min_buffer_count = min_buffer_count;
+        self
+    }
+    #[inline]
+    pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self {
+        self.inner.max_buffer_count = max_buffer_count;
+        self
+    }
+    #[inline]
+    pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self {
+        self.inner.min_buffer_count_for_camping = min_buffer_count_for_camping;
+        self
+    }
+    #[inline]
+    pub fn min_buffer_count_for_dedicated_slack(
+        mut self,
+        min_buffer_count_for_dedicated_slack: u32,
+    ) -> Self {
+        self.inner.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack;
+        self
+    }
+    #[inline]
+    pub fn min_buffer_count_for_shared_slack(
+        mut self,
+        min_buffer_count_for_shared_slack: u32,
+    ) -> Self {
+        self.inner.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> BufferCollectionConstraintsInfoFUCHSIA {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.html>"]
+pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub format_rgba10x6_without_y_cb_cr_sampler: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT;
+}
+impl PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
+        PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceRGBA10X6FormatsFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceRGBA10X6FormatsFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn format_rgba10x6_without_y_cb_cr_sampler(
+        mut self,
+        format_rgba10x6_without_y_cb_cr_sampler: bool,
+    ) -> Self {
+        self.inner.format_rgba10x6_without_y_cb_cr_sampler =
+            format_rgba10x6_without_y_cb_cr_sampler.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormatProperties3.html>"]
+pub struct FormatProperties3 {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub linear_tiling_features: FormatFeatureFlags2,
+    pub optimal_tiling_features: FormatFeatureFlags2,
+    pub buffer_features: FormatFeatureFlags2,
+}
+impl ::std::default::Default for FormatProperties3 {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            linear_tiling_features: FormatFeatureFlags2::default(),
+            optimal_tiling_features: FormatFeatureFlags2::default(),
+            buffer_features: FormatFeatureFlags2::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for FormatProperties3 {
+    const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_3;
+}
+impl FormatProperties3 {
+    pub fn builder<'a>() -> FormatProperties3Builder<'a> {
+        FormatProperties3Builder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct FormatProperties3Builder<'a> {
+    inner: FormatProperties3,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsFormatProperties2 for FormatProperties3Builder<'_> {}
+unsafe impl ExtendsFormatProperties2 for FormatProperties3 {}
+impl<'a> ::std::ops::Deref for FormatProperties3Builder<'a> {
+    type Target = FormatProperties3;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for FormatProperties3Builder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> FormatProperties3Builder<'a> {
+    #[inline]
+    pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self {
+        self.inner.linear_tiling_features = linear_tiling_features;
+        self
+    }
+    #[inline]
+    pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self {
+        self.inner.optimal_tiling_features = optimal_tiling_features;
+        self
+    }
+    #[inline]
+    pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self {
+        self.inner.buffer_features = buffer_features;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> FormatProperties3 {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierPropertiesList2EXT.html>"]
+pub struct DrmFormatModifierPropertiesList2EXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub drm_format_modifier_count: u32,
+    pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT,
+}
+impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            drm_format_modifier_count: u32::default(),
+            p_drm_format_modifier_properties: ::std::ptr::null_mut(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DrmFormatModifierPropertiesList2EXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT;
+}
+impl DrmFormatModifierPropertiesList2EXT {
+    pub fn builder<'a>() -> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
+        DrmFormatModifierPropertiesList2EXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DrmFormatModifierPropertiesList2EXTBuilder<'a> {
+    inner: DrmFormatModifierPropertiesList2EXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXTBuilder<'_> {}
+unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT {}
+impl<'a> ::std::ops::Deref for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
+    type Target = DrmFormatModifierPropertiesList2EXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DrmFormatModifierPropertiesList2EXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DrmFormatModifierPropertiesList2EXTBuilder<'a> {
+    #[inline]
+    pub fn drm_format_modifier_properties(
+        mut self,
+        drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT],
+    ) -> Self {
+        self.inner.drm_format_modifier_count = drm_format_modifier_properties.len() as _;
+        self.inner.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DrmFormatModifierPropertiesList2EXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDrmFormatModifierProperties2EXT.html>"]
+pub struct DrmFormatModifierProperties2EXT {
+    pub drm_format_modifier: u64,
+    pub drm_format_modifier_plane_count: u32,
+    pub drm_format_modifier_tiling_features: FormatFeatureFlags2,
+}
+impl DrmFormatModifierProperties2EXT {
+    pub fn builder<'a>() -> DrmFormatModifierProperties2EXTBuilder<'a> {
+        DrmFormatModifierProperties2EXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DrmFormatModifierProperties2EXTBuilder<'a> {
+    inner: DrmFormatModifierProperties2EXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DrmFormatModifierProperties2EXTBuilder<'a> {
+    type Target = DrmFormatModifierProperties2EXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DrmFormatModifierProperties2EXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DrmFormatModifierProperties2EXTBuilder<'a> {
+    #[inline]
+    pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
+        self.inner.drm_format_modifier = drm_format_modifier;
+        self
+    }
+    #[inline]
+    pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self {
+        self.inner.drm_format_modifier_plane_count = drm_format_modifier_plane_count;
+        self
+    }
+    #[inline]
+    pub fn drm_format_modifier_tiling_features(
+        mut self,
+        drm_format_modifier_tiling_features: FormatFeatureFlags2,
+    ) -> Self {
+        self.inner.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DrmFormatModifierProperties2EXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAndroidHardwareBufferFormatProperties2ANDROID.html>"]
+pub struct AndroidHardwareBufferFormatProperties2ANDROID {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub format: Format,
+    pub external_format: u64,
+    pub format_features: FormatFeatureFlags2,
+    pub sampler_ycbcr_conversion_components: ComponentMapping,
+    pub suggested_ycbcr_model: SamplerYcbcrModelConversion,
+    pub suggested_ycbcr_range: SamplerYcbcrRange,
+    pub suggested_x_chroma_offset: ChromaLocation,
+    pub suggested_y_chroma_offset: ChromaLocation,
+}
+impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            format: Format::default(),
+            external_format: u64::default(),
+            format_features: FormatFeatureFlags2::default(),
+            sampler_ycbcr_conversion_components: ComponentMapping::default(),
+            suggested_ycbcr_model: SamplerYcbcrModelConversion::default(),
+            suggested_ycbcr_range: SamplerYcbcrRange::default(),
+            suggested_x_chroma_offset: ChromaLocation::default(),
+            suggested_y_chroma_offset: ChromaLocation::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for AndroidHardwareBufferFormatProperties2ANDROID {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID;
+}
+impl AndroidHardwareBufferFormatProperties2ANDROID {
+    pub fn builder<'a>() -> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
+        AndroidHardwareBufferFormatProperties2ANDROIDBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
+    inner: AndroidHardwareBufferFormatProperties2ANDROID,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
+    for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'_>
+{
+}
+unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID
+    for AndroidHardwareBufferFormatProperties2ANDROID
+{
+}
+impl<'a> ::std::ops::Deref for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
+    type Target = AndroidHardwareBufferFormatProperties2ANDROID;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> AndroidHardwareBufferFormatProperties2ANDROIDBuilder<'a> {
+    #[inline]
+    pub fn format(mut self, format: Format) -> Self {
+        self.inner.format = format;
+        self
+    }
+    #[inline]
+    pub fn external_format(mut self, external_format: u64) -> Self {
+        self.inner.external_format = external_format;
+        self
+    }
+    #[inline]
+    pub fn format_features(mut self, format_features: FormatFeatureFlags2) -> Self {
+        self.inner.format_features = format_features;
+        self
+    }
+    #[inline]
+    pub fn sampler_ycbcr_conversion_components(
+        mut self,
+        sampler_ycbcr_conversion_components: ComponentMapping,
+    ) -> Self {
+        self.inner.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components;
+        self
+    }
+    #[inline]
+    pub fn suggested_ycbcr_model(
+        mut self,
+        suggested_ycbcr_model: SamplerYcbcrModelConversion,
+    ) -> Self {
+        self.inner.suggested_ycbcr_model = suggested_ycbcr_model;
+        self
+    }
+    #[inline]
+    pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self {
+        self.inner.suggested_ycbcr_range = suggested_ycbcr_range;
+        self
+    }
+    #[inline]
+    pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self {
+        self.inner.suggested_x_chroma_offset = suggested_x_chroma_offset;
+        self
+    }
+    #[inline]
+    pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self {
+        self.inner.suggested_y_chroma_offset = suggested_y_chroma_offset;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> AndroidHardwareBufferFormatProperties2ANDROID {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRenderingCreateInfo.html>"]
+pub struct PipelineRenderingCreateInfo {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub view_mask: u32,
+    pub color_attachment_count: u32,
+    pub p_color_attachment_formats: *const Format,
+    pub depth_attachment_format: Format,
+    pub stencil_attachment_format: Format,
+}
+impl ::std::default::Default for PipelineRenderingCreateInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            view_mask: u32::default(),
+            color_attachment_count: u32::default(),
+            p_color_attachment_formats: ::std::ptr::null(),
+            depth_attachment_format: Format::default(),
+            stencil_attachment_format: Format::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PipelineRenderingCreateInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RENDERING_CREATE_INFO;
+}
+impl PipelineRenderingCreateInfo {
+    pub fn builder<'a>() -> PipelineRenderingCreateInfoBuilder<'a> {
+        PipelineRenderingCreateInfoBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PipelineRenderingCreateInfoBuilder<'a> {
+    inner: PipelineRenderingCreateInfo,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfoBuilder<'_> {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo {}
+impl<'a> ::std::ops::Deref for PipelineRenderingCreateInfoBuilder<'a> {
+    type Target = PipelineRenderingCreateInfo;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PipelineRenderingCreateInfoBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PipelineRenderingCreateInfoBuilder<'a> {
+    #[inline]
+    pub fn view_mask(mut self, view_mask: u32) -> Self {
+        self.inner.view_mask = view_mask;
+        self
+    }
+    #[inline]
+    pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self {
+        self.inner.color_attachment_count = color_attachment_formats.len() as _;
+        self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self {
+        self.inner.depth_attachment_format = depth_attachment_format;
+        self
+    }
+    #[inline]
+    pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self {
+        self.inner.stencil_attachment_format = stencil_attachment_format;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PipelineRenderingCreateInfo {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingInfo.html>"]
+pub struct RenderingInfo {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub flags: RenderingFlags,
+    pub render_area: Rect2D,
+    pub layer_count: u32,
+    pub view_mask: u32,
+    pub color_attachment_count: u32,
+    pub p_color_attachments: *const RenderingAttachmentInfo,
+    pub p_depth_attachment: *const RenderingAttachmentInfo,
+    pub p_stencil_attachment: *const RenderingAttachmentInfo,
+}
+impl ::std::default::Default for RenderingInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            flags: RenderingFlags::default(),
+            render_area: Rect2D::default(),
+            layer_count: u32::default(),
+            view_mask: u32::default(),
+            color_attachment_count: u32::default(),
+            p_color_attachments: ::std::ptr::null(),
+            p_depth_attachment: ::std::ptr::null(),
+            p_stencil_attachment: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for RenderingInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_INFO;
+}
+impl RenderingInfo {
+    pub fn builder<'a>() -> RenderingInfoBuilder<'a> {
+        RenderingInfoBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct RenderingInfoBuilder<'a> {
+    inner: RenderingInfo,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+pub unsafe trait ExtendsRenderingInfo {}
+impl<'a> ::std::ops::Deref for RenderingInfoBuilder<'a> {
+    type Target = RenderingInfo;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for RenderingInfoBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> RenderingInfoBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: RenderingFlags) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn render_area(mut self, render_area: Rect2D) -> Self {
+        self.inner.render_area = render_area;
+        self
+    }
+    #[inline]
+    pub fn layer_count(mut self, layer_count: u32) -> Self {
+        self.inner.layer_count = layer_count;
+        self
+    }
+    #[inline]
+    pub fn view_mask(mut self, view_mask: u32) -> Self {
+        self.inner.view_mask = view_mask;
+        self
+    }
+    #[inline]
+    pub fn color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self {
+        self.inner.color_attachment_count = color_attachments.len() as _;
+        self.inner.p_color_attachments = color_attachments.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo) -> Self {
+        self.inner.p_depth_attachment = depth_attachment;
+        self
+    }
+    #[inline]
+    pub fn stencil_attachment(mut self, stencil_attachment: &'a RenderingAttachmentInfo) -> Self {
+        self.inner.p_stencil_attachment = stencil_attachment;
+        self
+    }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsRenderingInfo>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> RenderingInfo {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingAttachmentInfo.html>"]
+pub struct RenderingAttachmentInfo {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub image_view: ImageView,
+    pub image_layout: ImageLayout,
+    pub resolve_mode: ResolveModeFlags,
+    pub resolve_image_view: ImageView,
+    pub resolve_image_layout: ImageLayout,
+    pub load_op: AttachmentLoadOp,
+    pub store_op: AttachmentStoreOp,
+    pub clear_value: ClearValue,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for RenderingAttachmentInfo {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("RenderingAttachmentInfo")
+            .field("s_type", &self.s_type)
+            .field("p_next", &self.p_next)
+            .field("image_view", &self.image_view)
+            .field("image_layout", &self.image_layout)
+            .field("resolve_mode", &self.resolve_mode)
+            .field("resolve_image_view", &self.resolve_image_view)
+            .field("resolve_image_layout", &self.resolve_image_layout)
+            .field("load_op", &self.load_op)
+            .field("store_op", &self.store_op)
+            .field("clear_value", &"union")
+            .finish()
+    }
+}
+impl ::std::default::Default for RenderingAttachmentInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            image_view: ImageView::default(),
+            image_layout: ImageLayout::default(),
+            resolve_mode: ResolveModeFlags::default(),
+            resolve_image_view: ImageView::default(),
+            resolve_image_layout: ImageLayout::default(),
+            load_op: AttachmentLoadOp::default(),
+            store_op: AttachmentStoreOp::default(),
+            clear_value: ClearValue::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for RenderingAttachmentInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_ATTACHMENT_INFO;
+}
+impl RenderingAttachmentInfo {
+    pub fn builder<'a>() -> RenderingAttachmentInfoBuilder<'a> {
+        RenderingAttachmentInfoBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct RenderingAttachmentInfoBuilder<'a> {
+    inner: RenderingAttachmentInfo,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for RenderingAttachmentInfoBuilder<'a> {
+    type Target = RenderingAttachmentInfo;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for RenderingAttachmentInfoBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> RenderingAttachmentInfoBuilder<'a> {
+    #[inline]
+    pub fn image_view(mut self, image_view: ImageView) -> Self {
+        self.inner.image_view = image_view;
+        self
+    }
+    #[inline]
+    pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
+        self.inner.image_layout = image_layout;
+        self
+    }
+    #[inline]
+    pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self {
+        self.inner.resolve_mode = resolve_mode;
+        self
+    }
+    #[inline]
+    pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self {
+        self.inner.resolve_image_view = resolve_image_view;
+        self
+    }
+    #[inline]
+    pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self {
+        self.inner.resolve_image_layout = resolve_image_layout;
+        self
+    }
+    #[inline]
+    pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self {
+        self.inner.load_op = load_op;
+        self
+    }
+    #[inline]
+    pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self {
+        self.inner.store_op = store_op;
+        self
+    }
+    #[inline]
+    pub fn clear_value(mut self, clear_value: ClearValue) -> Self {
+        self.inner.clear_value = clear_value;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> RenderingAttachmentInfo {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentShadingRateAttachmentInfoKHR.html>"]
+pub struct RenderingFragmentShadingRateAttachmentInfoKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub image_view: ImageView,
+    pub image_layout: ImageLayout,
+    pub shading_rate_attachment_texel_size: Extent2D,
+}
+impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            image_view: ImageView::default(),
+            image_layout: ImageLayout::default(),
+            shading_rate_attachment_texel_size: Extent2D::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for RenderingFragmentShadingRateAttachmentInfoKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR;
+}
+impl RenderingFragmentShadingRateAttachmentInfoKHR {
+    pub fn builder<'a>() -> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
+        RenderingFragmentShadingRateAttachmentInfoKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
+    inner: RenderingFragmentShadingRateAttachmentInfoKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'_> {}
+unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR {}
+impl<'a> ::std::ops::Deref for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
+    type Target = RenderingFragmentShadingRateAttachmentInfoKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> RenderingFragmentShadingRateAttachmentInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn image_view(mut self, image_view: ImageView) -> Self {
+        self.inner.image_view = image_view;
+        self
+    }
+    #[inline]
+    pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
+        self.inner.image_layout = image_layout;
+        self
+    }
+    #[inline]
+    pub fn shading_rate_attachment_texel_size(
+        mut self,
+        shading_rate_attachment_texel_size: Extent2D,
+    ) -> Self {
+        self.inner.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> RenderingFragmentShadingRateAttachmentInfoKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html>"]
+pub struct RenderingFragmentDensityMapAttachmentInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub image_view: ImageView,
+    pub image_layout: ImageLayout,
+}
+impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            image_view: ImageView::default(),
+            image_layout: ImageLayout::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for RenderingFragmentDensityMapAttachmentInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT;
+}
+impl RenderingFragmentDensityMapAttachmentInfoEXT {
+    pub fn builder<'a>() -> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
+        RenderingFragmentDensityMapAttachmentInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
+    inner: RenderingFragmentDensityMapAttachmentInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'_> {}
+unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT {}
+impl<'a> ::std::ops::Deref for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
+    type Target = RenderingFragmentDensityMapAttachmentInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> RenderingFragmentDensityMapAttachmentInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn image_view(mut self, image_view: ImageView) -> Self {
+        self.inner.image_view = image_view;
+        self
+    }
+    #[inline]
+    pub fn image_layout(mut self, image_layout: ImageLayout) -> Self {
+        self.inner.image_layout = image_layout;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> RenderingFragmentDensityMapAttachmentInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDynamicRenderingFeatures.html>"]
+pub struct PhysicalDeviceDynamicRenderingFeatures {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub dynamic_rendering: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            dynamic_rendering: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDynamicRenderingFeatures {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
+}
+impl PhysicalDeviceDynamicRenderingFeatures {
+    pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
+        PhysicalDeviceDynamicRenderingFeaturesBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
+    inner: PhysicalDeviceDynamicRenderingFeatures,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeaturesBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
+    type Target = PhysicalDeviceDynamicRenderingFeatures;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDynamicRenderingFeaturesBuilder<'a> {
+    #[inline]
+    pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self {
+        self.inner.dynamic_rendering = dynamic_rendering.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDynamicRenderingFeatures {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferInheritanceRenderingInfo.html>"]
+pub struct CommandBufferInheritanceRenderingInfo {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub flags: RenderingFlags,
+    pub view_mask: u32,
+    pub color_attachment_count: u32,
+    pub p_color_attachment_formats: *const Format,
+    pub depth_attachment_format: Format,
+    pub stencil_attachment_format: Format,
+    pub rasterization_samples: SampleCountFlags,
+}
+impl ::std::default::Default for CommandBufferInheritanceRenderingInfo {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            flags: RenderingFlags::default(),
+            view_mask: u32::default(),
+            color_attachment_count: u32::default(),
+            p_color_attachment_formats: ::std::ptr::null(),
+            depth_attachment_format: Format::default(),
+            stencil_attachment_format: Format::default(),
+            rasterization_samples: SampleCountFlags::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for CommandBufferInheritanceRenderingInfo {
+    const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
+}
+impl CommandBufferInheritanceRenderingInfo {
+    pub fn builder<'a>() -> CommandBufferInheritanceRenderingInfoBuilder<'a> {
+        CommandBufferInheritanceRenderingInfoBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct CommandBufferInheritanceRenderingInfoBuilder<'a> {
+    inner: CommandBufferInheritanceRenderingInfo,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsCommandBufferInheritanceInfo
+    for CommandBufferInheritanceRenderingInfoBuilder<'_>
+{
+}
+unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo {}
+impl<'a> ::std::ops::Deref for CommandBufferInheritanceRenderingInfoBuilder<'a> {
+    type Target = CommandBufferInheritanceRenderingInfo;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for CommandBufferInheritanceRenderingInfoBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> CommandBufferInheritanceRenderingInfoBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: RenderingFlags) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn view_mask(mut self, view_mask: u32) -> Self {
+        self.inner.view_mask = view_mask;
+        self
+    }
+    #[inline]
+    pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self {
+        self.inner.color_attachment_count = color_attachment_formats.len() as _;
+        self.inner.p_color_attachment_formats = color_attachment_formats.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self {
+        self.inner.depth_attachment_format = depth_attachment_format;
+        self
+    }
+    #[inline]
+    pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self {
+        self.inner.stencil_attachment_format = stencil_attachment_format;
+        self
+    }
+    #[inline]
+    pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self {
+        self.inner.rasterization_samples = rasterization_samples;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> CommandBufferInheritanceRenderingInfo {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentSampleCountInfoAMD.html>"]
+pub struct AttachmentSampleCountInfoAMD {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub color_attachment_count: u32,
+    pub p_color_attachment_samples: *const SampleCountFlags,
+    pub depth_stencil_attachment_samples: SampleCountFlags,
+}
+impl ::std::default::Default for AttachmentSampleCountInfoAMD {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            color_attachment_count: u32::default(),
+            p_color_attachment_samples: ::std::ptr::null(),
+            depth_stencil_attachment_samples: SampleCountFlags::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for AttachmentSampleCountInfoAMD {
+    const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
+}
+impl AttachmentSampleCountInfoAMD {
+    pub fn builder<'a>() -> AttachmentSampleCountInfoAMDBuilder<'a> {
+        AttachmentSampleCountInfoAMDBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct AttachmentSampleCountInfoAMDBuilder<'a> {
+    inner: AttachmentSampleCountInfoAMD,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMDBuilder<'_> {}
+unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMDBuilder<'_> {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD {}
+impl<'a> ::std::ops::Deref for AttachmentSampleCountInfoAMDBuilder<'a> {
+    type Target = AttachmentSampleCountInfoAMD;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for AttachmentSampleCountInfoAMDBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> AttachmentSampleCountInfoAMDBuilder<'a> {
+    #[inline]
+    pub fn color_attachment_samples(
+        mut self,
+        color_attachment_samples: &'a [SampleCountFlags],
+    ) -> Self {
+        self.inner.color_attachment_count = color_attachment_samples.len() as _;
+        self.inner.p_color_attachment_samples = color_attachment_samples.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn depth_stencil_attachment_samples(
+        mut self,
+        depth_stencil_attachment_samples: SampleCountFlags,
+    ) -> Self {
+        self.inner.depth_stencil_attachment_samples = depth_stencil_attachment_samples;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> AttachmentSampleCountInfoAMD {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiviewPerViewAttributesInfoNVX.html>"]
+pub struct MultiviewPerViewAttributesInfoNVX {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub per_view_attributes: Bool32,
+    pub per_view_attributes_position_x_only: Bool32,
+}
+impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            per_view_attributes: Bool32::default(),
+            per_view_attributes_position_x_only: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for MultiviewPerViewAttributesInfoNVX {
+    const STRUCTURE_TYPE: StructureType = StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX;
+}
+impl MultiviewPerViewAttributesInfoNVX {
+    pub fn builder<'a>() -> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
+        MultiviewPerViewAttributesInfoNVXBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MultiviewPerViewAttributesInfoNVXBuilder<'a> {
+    inner: MultiviewPerViewAttributesInfoNVX,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
+unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX {}
+unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVXBuilder<'_> {}
+unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX {}
+impl<'a> ::std::ops::Deref for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
+    type Target = MultiviewPerViewAttributesInfoNVX;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MultiviewPerViewAttributesInfoNVXBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MultiviewPerViewAttributesInfoNVXBuilder<'a> {
+    #[inline]
+    pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self {
+        self.inner.per_view_attributes = per_view_attributes.into();
+        self
+    }
+    #[inline]
+    pub fn per_view_attributes_position_x_only(
+        mut self,
+        per_view_attributes_position_x_only: bool,
+    ) -> Self {
+        self.inner.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MultiviewPerViewAttributesInfoNVX {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageViewMinLodFeaturesEXT.html>"]
+pub struct PhysicalDeviceImageViewMinLodFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub min_lod: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            min_lod: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceImageViewMinLodFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT;
+}
+impl PhysicalDeviceImageViewMinLodFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
+        PhysicalDeviceImageViewMinLodFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceImageViewMinLodFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceImageViewMinLodFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn min_lod(mut self, min_lod: bool) -> Self {
+        self.inner.min_lod = min_lod.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceImageViewMinLodFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewMinLodCreateInfoEXT.html>"]
+pub struct ImageViewMinLodCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub min_lod: f32,
+}
+impl ::std::default::Default for ImageViewMinLodCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            min_lod: f32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageViewMinLodCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT;
+}
+impl ImageViewMinLodCreateInfoEXT {
+    pub fn builder<'a>() -> ImageViewMinLodCreateInfoEXTBuilder<'a> {
+        ImageViewMinLodCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageViewMinLodCreateInfoEXTBuilder<'a> {
+    inner: ImageViewMinLodCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for ImageViewMinLodCreateInfoEXTBuilder<'a> {
+    type Target = ImageViewMinLodCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageViewMinLodCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageViewMinLodCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn min_lod(mut self, min_lod: f32) -> Self {
+        self.inner.min_lod = min_lod;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageViewMinLodCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.html>"]
+pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub rasterization_order_color_attachment_access: Bool32,
+    pub rasterization_order_depth_attachment_access: Bool32,
+    pub rasterization_order_stencil_attachment_access: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            rasterization_order_color_attachment_access: Bool32::default(),
+            rasterization_order_depth_attachment_access: Bool32::default(),
+            rasterization_order_stencil_attachment_access: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
+}
+impl PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
+        PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
+{
+}
+impl<'a> ::std::ops::Deref
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a>
+{
+    type Target = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut
+    for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a>
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn rasterization_order_color_attachment_access(
+        mut self,
+        rasterization_order_color_attachment_access: bool,
+    ) -> Self {
+        self.inner.rasterization_order_color_attachment_access =
+            rasterization_order_color_attachment_access.into();
+        self
+    }
+    #[inline]
+    pub fn rasterization_order_depth_attachment_access(
+        mut self,
+        rasterization_order_depth_attachment_access: bool,
+    ) -> Self {
+        self.inner.rasterization_order_depth_attachment_access =
+            rasterization_order_depth_attachment_access.into();
+        self
+    }
+    #[inline]
+    pub fn rasterization_order_stencil_attachment_access(
+        mut self,
+        rasterization_order_stencil_attachment_access: bool,
+    ) -> Self {
+        self.inner.rasterization_order_stencil_attachment_access =
+            rasterization_order_stencil_attachment_access.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.html>"]
+pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub linear_color_attachment: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            linear_color_attachment: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceLinearColorAttachmentFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV;
+}
+impl PhysicalDeviceLinearColorAttachmentFeaturesNV {
+    pub fn builder<'a>() -> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
+        PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
+    inner: PhysicalDeviceLinearColorAttachmentFeaturesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
+    type Target = PhysicalDeviceLinearColorAttachmentFeaturesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNVBuilder<'a> {
+    #[inline]
+    pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self {
+        self.inner.linear_color_attachment = linear_color_attachment.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceLinearColorAttachmentFeaturesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.html>"]
+pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub graphics_pipeline_library: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            graphics_pipeline_library: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT;
+}
+impl PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
+        PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn graphics_pipeline_library(mut self, graphics_pipeline_library: bool) -> Self {
+        self.inner.graphics_pipeline_library = graphics_pipeline_library.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.html>"]
+pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub graphics_pipeline_library_fast_linking: Bool32,
+    pub graphics_pipeline_library_independent_interpolation_decoration: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            graphics_pipeline_library_fast_linking: Bool32::default(),
+            graphics_pipeline_library_independent_interpolation_decoration: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT;
+}
+impl PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
+        PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
+    inner: PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT
+{
+}
+impl<'a> ::std::ops::Deref for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
+    type Target = PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn graphics_pipeline_library_fast_linking(
+        mut self,
+        graphics_pipeline_library_fast_linking: bool,
+    ) -> Self {
+        self.inner.graphics_pipeline_library_fast_linking =
+            graphics_pipeline_library_fast_linking.into();
+        self
+    }
+    #[inline]
+    pub fn graphics_pipeline_library_independent_interpolation_decoration(
+        mut self,
+        graphics_pipeline_library_independent_interpolation_decoration: bool,
+    ) -> Self {
+        self.inner
+            .graphics_pipeline_library_independent_interpolation_decoration =
+            graphics_pipeline_library_independent_interpolation_decoration.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineLibraryCreateInfoEXT.html>"]
+pub struct GraphicsPipelineLibraryCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub flags: GraphicsPipelineLibraryFlagsEXT,
+}
+impl ::std::default::Default for GraphicsPipelineLibraryCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            flags: GraphicsPipelineLibraryFlagsEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for GraphicsPipelineLibraryCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT;
+}
+impl GraphicsPipelineLibraryCreateInfoEXT {
+    pub fn builder<'a>() -> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
+        GraphicsPipelineLibraryCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
+    inner: GraphicsPipelineLibraryCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
+    type Target = GraphicsPipelineLibraryCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> GraphicsPipelineLibraryCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: GraphicsPipelineLibraryFlagsEXT) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> GraphicsPipelineLibraryCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.html>"]
+pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub descriptor_set_host_mapping: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            descriptor_set_host_mapping: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE;
+}
+impl PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
+    pub fn builder<'a>() -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
+        PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
+    inner: PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
+    type Target = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVEBuilder<'a> {
+    #[inline]
+    pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self {
+        self.inner.descriptor_set_host_mapping = descriptor_set_host_mapping.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetBindingReferenceVALVE.html>"]
+pub struct DescriptorSetBindingReferenceVALVE {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub descriptor_set_layout: DescriptorSetLayout,
+    pub binding: u32,
+}
+impl ::std::default::Default for DescriptorSetBindingReferenceVALVE {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            descriptor_set_layout: DescriptorSetLayout::default(),
+            binding: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DescriptorSetBindingReferenceVALVE {
+    const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE;
+}
+impl DescriptorSetBindingReferenceVALVE {
+    pub fn builder<'a>() -> DescriptorSetBindingReferenceVALVEBuilder<'a> {
+        DescriptorSetBindingReferenceVALVEBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DescriptorSetBindingReferenceVALVEBuilder<'a> {
+    inner: DescriptorSetBindingReferenceVALVE,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DescriptorSetBindingReferenceVALVEBuilder<'a> {
+    type Target = DescriptorSetBindingReferenceVALVE;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DescriptorSetBindingReferenceVALVEBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DescriptorSetBindingReferenceVALVEBuilder<'a> {
+    #[inline]
+    pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self {
+        self.inner.descriptor_set_layout = descriptor_set_layout;
+        self
+    }
+    #[inline]
+    pub fn binding(mut self, binding: u32) -> Self {
+        self.inner.binding = binding;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DescriptorSetBindingReferenceVALVE {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorSetLayoutHostMappingInfoVALVE.html>"]
+pub struct DescriptorSetLayoutHostMappingInfoVALVE {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub descriptor_offset: usize,
+    pub descriptor_size: u32,
+}
+impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            descriptor_offset: usize::default(),
+            descriptor_size: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DescriptorSetLayoutHostMappingInfoVALVE {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE;
+}
+impl DescriptorSetLayoutHostMappingInfoVALVE {
+    pub fn builder<'a>() -> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
+        DescriptorSetLayoutHostMappingInfoVALVEBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
+    inner: DescriptorSetLayoutHostMappingInfoVALVE,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
+    type Target = DescriptorSetLayoutHostMappingInfoVALVE;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DescriptorSetLayoutHostMappingInfoVALVEBuilder<'a> {
+    #[inline]
+    pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self {
+        self.inner.descriptor_offset = descriptor_offset;
+        self
+    }
+    #[inline]
+    pub fn descriptor_size(mut self, descriptor_size: u32) -> Self {
+        self.inner.descriptor_size = descriptor_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DescriptorSetLayoutHostMappingInfoVALVE {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.html>"]
+pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_module_identifier: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            shader_module_identifier: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT;
+}
+impl PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
+        PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceShaderModuleIdentifierFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceShaderModuleIdentifierFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn shader_module_identifier(mut self, shader_module_identifier: bool) -> Self {
+        self.inner.shader_module_identifier = shader_module_identifier.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.html>"]
+pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE],
+}
+impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            shader_module_identifier_algorithm_uuid: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT;
+}
+impl PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
+        PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
+    inner: PhysicalDeviceShaderModuleIdentifierPropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderModuleIdentifierPropertiesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
+    type Target = PhysicalDeviceShaderModuleIdentifierPropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn shader_module_identifier_algorithm_uuid(
+        mut self,
+        shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE],
+    ) -> Self {
+        self.inner.shader_module_identifier_algorithm_uuid =
+            shader_module_identifier_algorithm_uuid;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineShaderStageModuleIdentifierCreateInfoEXT.html>"]
+pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub identifier_size: u32,
+    pub p_identifier: *const u8,
+}
+impl ::std::default::Default for PipelineShaderStageModuleIdentifierCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            identifier_size: u32::default(),
+            p_identifier: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PipelineShaderStageModuleIdentifierCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT;
+}
+impl PipelineShaderStageModuleIdentifierCreateInfoEXT {
+    pub fn builder<'a>() -> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
+        PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
+    inner: PipelineShaderStageModuleIdentifierCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPipelineShaderStageCreateInfo
+    for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPipelineShaderStageCreateInfo
+    for PipelineShaderStageModuleIdentifierCreateInfoEXT
+{
+}
+impl<'a> ::std::ops::Deref for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
+    type Target = PipelineShaderStageModuleIdentifierCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn identifier(mut self, identifier: &'a [u8]) -> Self {
+        self.inner.identifier_size = identifier.len() as _;
+        self.inner.p_identifier = identifier.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PipelineShaderStageModuleIdentifierCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderModuleIdentifierEXT.html>"]
+pub struct ShaderModuleIdentifierEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub identifier_size: u32,
+    pub identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT],
+}
+impl ::std::default::Default for ShaderModuleIdentifierEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            identifier_size: u32::default(),
+            identifier: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ShaderModuleIdentifierEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_IDENTIFIER_EXT;
+}
+impl ShaderModuleIdentifierEXT {
+    pub fn builder<'a>() -> ShaderModuleIdentifierEXTBuilder<'a> {
+        ShaderModuleIdentifierEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ShaderModuleIdentifierEXTBuilder<'a> {
+    inner: ShaderModuleIdentifierEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for ShaderModuleIdentifierEXTBuilder<'a> {
+    type Target = ShaderModuleIdentifierEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ShaderModuleIdentifierEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ShaderModuleIdentifierEXTBuilder<'a> {
+    #[inline]
+    pub fn identifier_size(mut self, identifier_size: u32) -> Self {
+        self.inner.identifier_size = identifier_size;
+        self
+    }
+    #[inline]
+    pub fn identifier(mut self, identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]) -> Self {
+        self.inner.identifier = identifier;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ShaderModuleIdentifierEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionControlEXT.html>"]
+pub struct ImageCompressionControlEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub flags: ImageCompressionFlagsEXT,
+    pub compression_control_plane_count: u32,
+    pub p_fixed_rate_flags: *mut ImageCompressionFixedRateFlagsEXT,
+}
+impl ::std::default::Default for ImageCompressionControlEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            flags: ImageCompressionFlagsEXT::default(),
+            compression_control_plane_count: u32::default(),
+            p_fixed_rate_flags: ::std::ptr::null_mut(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageCompressionControlEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_CONTROL_EXT;
+}
+impl ImageCompressionControlEXT {
+    pub fn builder<'a>() -> ImageCompressionControlEXTBuilder<'a> {
+        ImageCompressionControlEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageCompressionControlEXTBuilder<'a> {
+    inner: ImageCompressionControlEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXTBuilder<'_> {}
+unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXT {}
+unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXTBuilder<'_> {}
+unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXT {}
+unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXT {}
+impl<'a> ::std::ops::Deref for ImageCompressionControlEXTBuilder<'a> {
+    type Target = ImageCompressionControlEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageCompressionControlEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageCompressionControlEXTBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: ImageCompressionFlagsEXT) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn fixed_rate_flags(
+        mut self,
+        fixed_rate_flags: &'a mut [ImageCompressionFixedRateFlagsEXT],
+    ) -> Self {
+        self.inner.compression_control_plane_count = fixed_rate_flags.len() as _;
+        self.inner.p_fixed_rate_flags = fixed_rate_flags.as_mut_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageCompressionControlEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageCompressionControlFeaturesEXT.html>"]
+pub struct PhysicalDeviceImageCompressionControlFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub image_compression_control: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceImageCompressionControlFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            image_compression_control: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceImageCompressionControlFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT;
+}
+impl PhysicalDeviceImageCompressionControlFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
+        PhysicalDeviceImageCompressionControlFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceImageCompressionControlFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageCompressionControlFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceImageCompressionControlFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn image_compression_control(mut self, image_compression_control: bool) -> Self {
+        self.inner.image_compression_control = image_compression_control.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceImageCompressionControlFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageCompressionPropertiesEXT.html>"]
+pub struct ImageCompressionPropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub image_compression_flags: ImageCompressionFlagsEXT,
+    pub image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT,
+}
+impl ::std::default::Default for ImageCompressionPropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            image_compression_flags: ImageCompressionFlagsEXT::default(),
+            image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageCompressionPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT;
+}
+impl ImageCompressionPropertiesEXT {
+    pub fn builder<'a>() -> ImageCompressionPropertiesEXTBuilder<'a> {
+        ImageCompressionPropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageCompressionPropertiesEXTBuilder<'a> {
+    inner: ImageCompressionPropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXTBuilder<'_> {}
+unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXT {}
+unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXTBuilder<'_> {}
+unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXT {}
+unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXTBuilder<'_> {}
+unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXT {}
+impl<'a> ::std::ops::Deref for ImageCompressionPropertiesEXTBuilder<'a> {
+    type Target = ImageCompressionPropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageCompressionPropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageCompressionPropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn image_compression_flags(
+        mut self,
+        image_compression_flags: ImageCompressionFlagsEXT,
+    ) -> Self {
+        self.inner.image_compression_flags = image_compression_flags;
+        self
+    }
+    #[inline]
+    pub fn image_compression_fixed_rate_flags(
+        mut self,
+        image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT,
+    ) -> Self {
+        self.inner.image_compression_fixed_rate_flags = image_compression_fixed_rate_flags;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageCompressionPropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.html>"]
+pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub image_compression_control_swapchain: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            image_compression_control_swapchain: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT;
+}
+impl PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
+        PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {}
+impl<'a> ::std::ops::Deref
+    for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a>
+{
+    type Target = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut
+    for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a>
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn image_compression_control_swapchain(
+        mut self,
+        image_compression_control_swapchain: bool,
+    ) -> Self {
+        self.inner.image_compression_control_swapchain = image_compression_control_swapchain.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageSubresource2EXT.html>"]
+pub struct ImageSubresource2EXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub image_subresource: ImageSubresource,
+}
+impl ::std::default::Default for ImageSubresource2EXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            image_subresource: ImageSubresource::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageSubresource2EXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SUBRESOURCE_2_EXT;
+}
+impl ImageSubresource2EXT {
+    pub fn builder<'a>() -> ImageSubresource2EXTBuilder<'a> {
+        ImageSubresource2EXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageSubresource2EXTBuilder<'a> {
+    inner: ImageSubresource2EXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for ImageSubresource2EXTBuilder<'a> {
+    type Target = ImageSubresource2EXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageSubresource2EXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageSubresource2EXTBuilder<'a> {
+    #[inline]
+    pub fn image_subresource(mut self, image_subresource: ImageSubresource) -> Self {
+        self.inner.image_subresource = image_subresource;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageSubresource2EXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubresourceLayout2EXT.html>"]
+pub struct SubresourceLayout2EXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub subresource_layout: SubresourceLayout,
+}
+impl ::std::default::Default for SubresourceLayout2EXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            subresource_layout: SubresourceLayout::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SubresourceLayout2EXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SUBRESOURCE_LAYOUT_2_EXT;
+}
+impl SubresourceLayout2EXT {
+    pub fn builder<'a>() -> SubresourceLayout2EXTBuilder<'a> {
+        SubresourceLayout2EXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SubresourceLayout2EXTBuilder<'a> {
+    inner: SubresourceLayout2EXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+pub unsafe trait ExtendsSubresourceLayout2EXT {}
+impl<'a> ::std::ops::Deref for SubresourceLayout2EXTBuilder<'a> {
+    type Target = SubresourceLayout2EXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SubresourceLayout2EXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SubresourceLayout2EXTBuilder<'a> {
+    #[inline]
+    pub fn subresource_layout(mut self, subresource_layout: SubresourceLayout) -> Self {
+        self.inner.subresource_layout = subresource_layout;
+        self
+    }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsSubresourceLayout2EXT>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*mut T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SubresourceLayout2EXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreationControlEXT.html>"]
+pub struct RenderPassCreationControlEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub disallow_merging: Bool32,
+}
+impl ::std::default::Default for RenderPassCreationControlEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            disallow_merging: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for RenderPassCreationControlEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATION_CONTROL_EXT;
+}
+impl RenderPassCreationControlEXT {
+    pub fn builder<'a>() -> RenderPassCreationControlEXTBuilder<'a> {
+        RenderPassCreationControlEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct RenderPassCreationControlEXTBuilder<'a> {
+    inner: RenderPassCreationControlEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXTBuilder<'_> {}
+unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXT {}
+unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXTBuilder<'_> {}
+unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXT {}
+impl<'a> ::std::ops::Deref for RenderPassCreationControlEXTBuilder<'a> {
+    type Target = RenderPassCreationControlEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for RenderPassCreationControlEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> RenderPassCreationControlEXTBuilder<'a> {
+    #[inline]
+    pub fn disallow_merging(mut self, disallow_merging: bool) -> Self {
+        self.inner.disallow_merging = disallow_merging.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> RenderPassCreationControlEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreationFeedbackInfoEXT.html>"]
+pub struct RenderPassCreationFeedbackInfoEXT {
+    pub post_merge_subpass_count: u32,
+}
+impl RenderPassCreationFeedbackInfoEXT {
+    pub fn builder<'a>() -> RenderPassCreationFeedbackInfoEXTBuilder<'a> {
+        RenderPassCreationFeedbackInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct RenderPassCreationFeedbackInfoEXTBuilder<'a> {
+    inner: RenderPassCreationFeedbackInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackInfoEXTBuilder<'a> {
+    type Target = RenderPassCreationFeedbackInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> RenderPassCreationFeedbackInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn post_merge_subpass_count(mut self, post_merge_subpass_count: u32) -> Self {
+        self.inner.post_merge_subpass_count = post_merge_subpass_count;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> RenderPassCreationFeedbackInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassCreationFeedbackCreateInfoEXT.html>"]
+pub struct RenderPassCreationFeedbackCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub p_render_pass_feedback: *mut RenderPassCreationFeedbackInfoEXT,
+}
+impl ::std::default::Default for RenderPassCreationFeedbackCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            p_render_pass_feedback: ::std::ptr::null_mut(),
+        }
+    }
+}
+unsafe impl TaggedStructure for RenderPassCreationFeedbackCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT;
+}
+impl RenderPassCreationFeedbackCreateInfoEXT {
+    pub fn builder<'a>() -> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
+        RenderPassCreationFeedbackCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
+    inner: RenderPassCreationFeedbackCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
+    type Target = RenderPassCreationFeedbackCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> RenderPassCreationFeedbackCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn render_pass_feedback(
+        mut self,
+        render_pass_feedback: &'a mut RenderPassCreationFeedbackInfoEXT,
+    ) -> Self {
+        self.inner.p_render_pass_feedback = render_pass_feedback;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> RenderPassCreationFeedbackCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSubpassFeedbackInfoEXT.html>"]
+pub struct RenderPassSubpassFeedbackInfoEXT {
+    pub subpass_merge_status: SubpassMergeStatusEXT,
+    pub description: [c_char; MAX_DESCRIPTION_SIZE],
+    pub post_merge_index: u32,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for RenderPassSubpassFeedbackInfoEXT {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("RenderPassSubpassFeedbackInfoEXT")
+            .field("subpass_merge_status", &self.subpass_merge_status)
+            .field("description", &unsafe {
+                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
+            })
+            .field("post_merge_index", &self.post_merge_index)
+            .finish()
+    }
+}
+impl ::std::default::Default for RenderPassSubpassFeedbackInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            subpass_merge_status: SubpassMergeStatusEXT::default(),
+            description: unsafe { ::std::mem::zeroed() },
+            post_merge_index: u32::default(),
+        }
+    }
+}
+impl RenderPassSubpassFeedbackInfoEXT {
+    pub fn builder<'a>() -> RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
+        RenderPassSubpassFeedbackInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
+    inner: RenderPassSubpassFeedbackInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
+    type Target = RenderPassSubpassFeedbackInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> RenderPassSubpassFeedbackInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn subpass_merge_status(mut self, subpass_merge_status: SubpassMergeStatusEXT) -> Self {
+        self.inner.subpass_merge_status = subpass_merge_status;
+        self
+    }
+    #[inline]
+    pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
+        self.inner.description = description;
+        self
+    }
+    #[inline]
+    pub fn post_merge_index(mut self, post_merge_index: u32) -> Self {
+        self.inner.post_merge_index = post_merge_index;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> RenderPassSubpassFeedbackInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRenderPassSubpassFeedbackCreateInfoEXT.html>"]
+pub struct RenderPassSubpassFeedbackCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub p_subpass_feedback: *mut RenderPassSubpassFeedbackInfoEXT,
+}
+impl ::std::default::Default for RenderPassSubpassFeedbackCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            p_subpass_feedback: ::std::ptr::null_mut(),
+        }
+    }
+}
+unsafe impl TaggedStructure for RenderPassSubpassFeedbackCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT;
+}
+impl RenderPassSubpassFeedbackCreateInfoEXT {
+    pub fn builder<'a>() -> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
+        RenderPassSubpassFeedbackCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
+    inner: RenderPassSubpassFeedbackCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
+    type Target = RenderPassSubpassFeedbackCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> RenderPassSubpassFeedbackCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn subpass_feedback(
+        mut self,
+        subpass_feedback: &'a mut RenderPassSubpassFeedbackInfoEXT,
+    ) -> Self {
+        self.inner.p_subpass_feedback = subpass_feedback;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> RenderPassSubpassFeedbackCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.html>"]
+pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub subpass_merge_feedback: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            subpass_merge_feedback: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT;
+}
+impl PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
+        PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceSubpassMergeFeedbackFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn subpass_merge_feedback(mut self, subpass_merge_feedback: bool) -> Self {
+        self.inner.subpass_merge_feedback = subpass_merge_feedback.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapBuildInfoEXT.html>"]
+pub struct MicromapBuildInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub ty: MicromapTypeEXT,
+    pub flags: BuildMicromapFlagsEXT,
+    pub mode: BuildMicromapModeEXT,
+    pub dst_micromap: MicromapEXT,
+    pub usage_counts_count: u32,
+    pub p_usage_counts: *const MicromapUsageEXT,
+    pub pp_usage_counts: *const *const MicromapUsageEXT,
+    pub data: DeviceOrHostAddressConstKHR,
+    pub scratch_data: DeviceOrHostAddressKHR,
+    pub triangle_array: DeviceOrHostAddressConstKHR,
+    pub triangle_array_stride: DeviceSize,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for MicromapBuildInfoEXT {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("MicromapBuildInfoEXT")
+            .field("s_type", &self.s_type)
+            .field("p_next", &self.p_next)
+            .field("ty", &self.ty)
+            .field("flags", &self.flags)
+            .field("mode", &self.mode)
+            .field("dst_micromap", &self.dst_micromap)
+            .field("usage_counts_count", &self.usage_counts_count)
+            .field("p_usage_counts", &self.p_usage_counts)
+            .field("pp_usage_counts", &self.pp_usage_counts)
+            .field("data", &"union")
+            .field("scratch_data", &"union")
+            .field("triangle_array", &"union")
+            .field("triangle_array_stride", &self.triangle_array_stride)
+            .finish()
+    }
+}
+impl ::std::default::Default for MicromapBuildInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            ty: MicromapTypeEXT::default(),
+            flags: BuildMicromapFlagsEXT::default(),
+            mode: BuildMicromapModeEXT::default(),
+            dst_micromap: MicromapEXT::default(),
+            usage_counts_count: u32::default(),
+            p_usage_counts: ::std::ptr::null(),
+            pp_usage_counts: ::std::ptr::null(),
+            data: DeviceOrHostAddressConstKHR::default(),
+            scratch_data: DeviceOrHostAddressKHR::default(),
+            triangle_array: DeviceOrHostAddressConstKHR::default(),
+            triangle_array_stride: DeviceSize::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for MicromapBuildInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_INFO_EXT;
+}
+impl MicromapBuildInfoEXT {
+    pub fn builder<'a>() -> MicromapBuildInfoEXTBuilder<'a> {
+        MicromapBuildInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MicromapBuildInfoEXTBuilder<'a> {
+    inner: MicromapBuildInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for MicromapBuildInfoEXTBuilder<'a> {
+    type Target = MicromapBuildInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MicromapBuildInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MicromapBuildInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn ty(mut self, ty: MicromapTypeEXT) -> Self {
+        self.inner.ty = ty;
+        self
+    }
+    #[inline]
+    pub fn flags(mut self, flags: BuildMicromapFlagsEXT) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn mode(mut self, mode: BuildMicromapModeEXT) -> Self {
+        self.inner.mode = mode;
+        self
+    }
+    #[inline]
+    pub fn dst_micromap(mut self, dst_micromap: MicromapEXT) -> Self {
+        self.inner.dst_micromap = dst_micromap;
+        self
+    }
+    #[inline]
+    pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self {
+        self.inner.usage_counts_count = usage_counts.len() as _;
+        self.inner.p_usage_counts = usage_counts.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self {
+        self.inner.usage_counts_count = usage_counts_ptrs.len() as _;
+        self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast();
+        self
+    }
+    #[inline]
+    pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self {
+        self.inner.data = data;
+        self
+    }
+    #[inline]
+    pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self {
+        self.inner.scratch_data = scratch_data;
+        self
+    }
+    #[inline]
+    pub fn triangle_array(mut self, triangle_array: DeviceOrHostAddressConstKHR) -> Self {
+        self.inner.triangle_array = triangle_array;
+        self
+    }
+    #[inline]
+    pub fn triangle_array_stride(mut self, triangle_array_stride: DeviceSize) -> Self {
+        self.inner.triangle_array_stride = triangle_array_stride;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MicromapBuildInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapCreateInfoEXT.html>"]
+pub struct MicromapCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub create_flags: MicromapCreateFlagsEXT,
+    pub buffer: Buffer,
+    pub offset: DeviceSize,
+    pub size: DeviceSize,
+    pub ty: MicromapTypeEXT,
+    pub device_address: DeviceAddress,
+}
+impl ::std::default::Default for MicromapCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            create_flags: MicromapCreateFlagsEXT::default(),
+            buffer: Buffer::default(),
+            offset: DeviceSize::default(),
+            size: DeviceSize::default(),
+            ty: MicromapTypeEXT::default(),
+            device_address: DeviceAddress::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for MicromapCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_CREATE_INFO_EXT;
+}
+impl MicromapCreateInfoEXT {
+    pub fn builder<'a>() -> MicromapCreateInfoEXTBuilder<'a> {
+        MicromapCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MicromapCreateInfoEXTBuilder<'a> {
+    inner: MicromapCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for MicromapCreateInfoEXTBuilder<'a> {
+    type Target = MicromapCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MicromapCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MicromapCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn create_flags(mut self, create_flags: MicromapCreateFlagsEXT) -> Self {
+        self.inner.create_flags = create_flags;
+        self
+    }
+    #[inline]
+    pub fn buffer(mut self, buffer: Buffer) -> Self {
+        self.inner.buffer = buffer;
+        self
+    }
+    #[inline]
+    pub fn offset(mut self, offset: DeviceSize) -> Self {
+        self.inner.offset = offset;
+        self
+    }
+    #[inline]
+    pub fn size(mut self, size: DeviceSize) -> Self {
+        self.inner.size = size;
+        self
+    }
+    #[inline]
+    pub fn ty(mut self, ty: MicromapTypeEXT) -> Self {
+        self.inner.ty = ty;
+        self
+    }
+    #[inline]
+    pub fn device_address(mut self, device_address: DeviceAddress) -> Self {
+        self.inner.device_address = device_address;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MicromapCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapVersionInfoEXT.html>"]
+pub struct MicromapVersionInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub p_version_data: *const [u8; 2 * UUID_SIZE],
+}
+impl ::std::default::Default for MicromapVersionInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            p_version_data: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for MicromapVersionInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_VERSION_INFO_EXT;
+}
+impl MicromapVersionInfoEXT {
+    pub fn builder<'a>() -> MicromapVersionInfoEXTBuilder<'a> {
+        MicromapVersionInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MicromapVersionInfoEXTBuilder<'a> {
+    inner: MicromapVersionInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for MicromapVersionInfoEXTBuilder<'a> {
+    type Target = MicromapVersionInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MicromapVersionInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MicromapVersionInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self {
+        self.inner.p_version_data = version_data;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MicromapVersionInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMicromapInfoEXT.html>"]
+pub struct CopyMicromapInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub src: MicromapEXT,
+    pub dst: MicromapEXT,
+    pub mode: CopyMicromapModeEXT,
+}
+impl ::std::default::Default for CopyMicromapInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            src: MicromapEXT::default(),
+            dst: MicromapEXT::default(),
+            mode: CopyMicromapModeEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for CopyMicromapInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_INFO_EXT;
+}
+impl CopyMicromapInfoEXT {
+    pub fn builder<'a>() -> CopyMicromapInfoEXTBuilder<'a> {
+        CopyMicromapInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct CopyMicromapInfoEXTBuilder<'a> {
+    inner: CopyMicromapInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for CopyMicromapInfoEXTBuilder<'a> {
+    type Target = CopyMicromapInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for CopyMicromapInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> CopyMicromapInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn src(mut self, src: MicromapEXT) -> Self {
+        self.inner.src = src;
+        self
+    }
+    #[inline]
+    pub fn dst(mut self, dst: MicromapEXT) -> Self {
+        self.inner.dst = dst;
+        self
+    }
+    #[inline]
+    pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self {
+        self.inner.mode = mode;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> CopyMicromapInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMicromapToMemoryInfoEXT.html>"]
+pub struct CopyMicromapToMemoryInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub src: MicromapEXT,
+    pub dst: DeviceOrHostAddressKHR,
+    pub mode: CopyMicromapModeEXT,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for CopyMicromapToMemoryInfoEXT {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("CopyMicromapToMemoryInfoEXT")
+            .field("s_type", &self.s_type)
+            .field("p_next", &self.p_next)
+            .field("src", &self.src)
+            .field("dst", &"union")
+            .field("mode", &self.mode)
+            .finish()
+    }
+}
+impl ::std::default::Default for CopyMicromapToMemoryInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            src: MicromapEXT::default(),
+            dst: DeviceOrHostAddressKHR::default(),
+            mode: CopyMicromapModeEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for CopyMicromapToMemoryInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_TO_MEMORY_INFO_EXT;
+}
+impl CopyMicromapToMemoryInfoEXT {
+    pub fn builder<'a>() -> CopyMicromapToMemoryInfoEXTBuilder<'a> {
+        CopyMicromapToMemoryInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct CopyMicromapToMemoryInfoEXTBuilder<'a> {
+    inner: CopyMicromapToMemoryInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for CopyMicromapToMemoryInfoEXTBuilder<'a> {
+    type Target = CopyMicromapToMemoryInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for CopyMicromapToMemoryInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> CopyMicromapToMemoryInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn src(mut self, src: MicromapEXT) -> Self {
+        self.inner.src = src;
+        self
+    }
+    #[inline]
+    pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self {
+        self.inner.dst = dst;
+        self
+    }
+    #[inline]
+    pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self {
+        self.inner.mode = mode;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> CopyMicromapToMemoryInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMemoryToMicromapInfoEXT.html>"]
+pub struct CopyMemoryToMicromapInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub src: DeviceOrHostAddressConstKHR,
+    pub dst: MicromapEXT,
+    pub mode: CopyMicromapModeEXT,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for CopyMemoryToMicromapInfoEXT {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("CopyMemoryToMicromapInfoEXT")
+            .field("s_type", &self.s_type)
+            .field("p_next", &self.p_next)
+            .field("src", &"union")
+            .field("dst", &self.dst)
+            .field("mode", &self.mode)
+            .finish()
+    }
+}
+impl ::std::default::Default for CopyMemoryToMicromapInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            src: DeviceOrHostAddressConstKHR::default(),
+            dst: MicromapEXT::default(),
+            mode: CopyMicromapModeEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for CopyMemoryToMicromapInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::COPY_MEMORY_TO_MICROMAP_INFO_EXT;
+}
+impl CopyMemoryToMicromapInfoEXT {
+    pub fn builder<'a>() -> CopyMemoryToMicromapInfoEXTBuilder<'a> {
+        CopyMemoryToMicromapInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct CopyMemoryToMicromapInfoEXTBuilder<'a> {
+    inner: CopyMemoryToMicromapInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for CopyMemoryToMicromapInfoEXTBuilder<'a> {
+    type Target = CopyMemoryToMicromapInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for CopyMemoryToMicromapInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> CopyMemoryToMicromapInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self {
+        self.inner.src = src;
+        self
+    }
+    #[inline]
+    pub fn dst(mut self, dst: MicromapEXT) -> Self {
+        self.inner.dst = dst;
+        self
+    }
+    #[inline]
+    pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self {
+        self.inner.mode = mode;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> CopyMemoryToMicromapInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapBuildSizesInfoEXT.html>"]
+pub struct MicromapBuildSizesInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub micromap_size: DeviceSize,
+    pub build_scratch_size: DeviceSize,
+    pub discardable: Bool32,
+}
+impl ::std::default::Default for MicromapBuildSizesInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            micromap_size: DeviceSize::default(),
+            build_scratch_size: DeviceSize::default(),
+            discardable: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for MicromapBuildSizesInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_SIZES_INFO_EXT;
+}
+impl MicromapBuildSizesInfoEXT {
+    pub fn builder<'a>() -> MicromapBuildSizesInfoEXTBuilder<'a> {
+        MicromapBuildSizesInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MicromapBuildSizesInfoEXTBuilder<'a> {
+    inner: MicromapBuildSizesInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for MicromapBuildSizesInfoEXTBuilder<'a> {
+    type Target = MicromapBuildSizesInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MicromapBuildSizesInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MicromapBuildSizesInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn micromap_size(mut self, micromap_size: DeviceSize) -> Self {
+        self.inner.micromap_size = micromap_size;
+        self
+    }
+    #[inline]
+    pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self {
+        self.inner.build_scratch_size = build_scratch_size;
+        self
+    }
+    #[inline]
+    pub fn discardable(mut self, discardable: bool) -> Self {
+        self.inner.discardable = discardable.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MicromapBuildSizesInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapUsageEXT.html>"]
+pub struct MicromapUsageEXT {
+    pub count: u32,
+    pub subdivision_level: u32,
+    pub format: u32,
+}
+impl MicromapUsageEXT {
+    pub fn builder<'a>() -> MicromapUsageEXTBuilder<'a> {
+        MicromapUsageEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MicromapUsageEXTBuilder<'a> {
+    inner: MicromapUsageEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for MicromapUsageEXTBuilder<'a> {
+    type Target = MicromapUsageEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MicromapUsageEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MicromapUsageEXTBuilder<'a> {
+    #[inline]
+    pub fn count(mut self, count: u32) -> Self {
+        self.inner.count = count;
+        self
+    }
+    #[inline]
+    pub fn subdivision_level(mut self, subdivision_level: u32) -> Self {
+        self.inner.subdivision_level = subdivision_level;
+        self
+    }
+    #[inline]
+    pub fn format(mut self, format: u32) -> Self {
+        self.inner.format = format;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MicromapUsageEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapTriangleEXT.html>"]
+pub struct MicromapTriangleEXT {
+    pub data_offset: u32,
+    pub subdivision_level: u16,
+    pub format: u16,
+}
+impl MicromapTriangleEXT {
+    pub fn builder<'a>() -> MicromapTriangleEXTBuilder<'a> {
+        MicromapTriangleEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MicromapTriangleEXTBuilder<'a> {
+    inner: MicromapTriangleEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for MicromapTriangleEXTBuilder<'a> {
+    type Target = MicromapTriangleEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MicromapTriangleEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MicromapTriangleEXTBuilder<'a> {
+    #[inline]
+    pub fn data_offset(mut self, data_offset: u32) -> Self {
+        self.inner.data_offset = data_offset;
+        self
+    }
+    #[inline]
+    pub fn subdivision_level(mut self, subdivision_level: u16) -> Self {
+        self.inner.subdivision_level = subdivision_level;
+        self
+    }
+    #[inline]
+    pub fn format(mut self, format: u16) -> Self {
+        self.inner.format = format;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MicromapTriangleEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpacityMicromapFeaturesEXT.html>"]
+pub struct PhysicalDeviceOpacityMicromapFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub micromap: Bool32,
+    pub micromap_capture_replay: Bool32,
+    pub micromap_host_commands: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceOpacityMicromapFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            micromap: Bool32::default(),
+            micromap_capture_replay: Bool32::default(),
+            micromap_host_commands: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceOpacityMicromapFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT;
+}
+impl PhysicalDeviceOpacityMicromapFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
+        PhysicalDeviceOpacityMicromapFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceOpacityMicromapFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceOpacityMicromapFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceOpacityMicromapFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn micromap(mut self, micromap: bool) -> Self {
+        self.inner.micromap = micromap.into();
+        self
+    }
+    #[inline]
+    pub fn micromap_capture_replay(mut self, micromap_capture_replay: bool) -> Self {
+        self.inner.micromap_capture_replay = micromap_capture_replay.into();
+        self
+    }
+    #[inline]
+    pub fn micromap_host_commands(mut self, micromap_host_commands: bool) -> Self {
+        self.inner.micromap_host_commands = micromap_host_commands.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceOpacityMicromapFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpacityMicromapPropertiesEXT.html>"]
+pub struct PhysicalDeviceOpacityMicromapPropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub max_opacity2_state_subdivision_level: u32,
+    pub max_opacity4_state_subdivision_level: u32,
+}
+impl ::std::default::Default for PhysicalDeviceOpacityMicromapPropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            max_opacity2_state_subdivision_level: u32::default(),
+            max_opacity4_state_subdivision_level: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceOpacityMicromapPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT;
+}
+impl PhysicalDeviceOpacityMicromapPropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
+        PhysicalDeviceOpacityMicromapPropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
+    inner: PhysicalDeviceOpacityMicromapPropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpacityMicromapPropertiesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
+    type Target = PhysicalDeviceOpacityMicromapPropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceOpacityMicromapPropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn max_opacity2_state_subdivision_level(
+        mut self,
+        max_opacity2_state_subdivision_level: u32,
+    ) -> Self {
+        self.inner.max_opacity2_state_subdivision_level = max_opacity2_state_subdivision_level;
+        self
+    }
+    #[inline]
+    pub fn max_opacity4_state_subdivision_level(
+        mut self,
+        max_opacity4_state_subdivision_level: u32,
+    ) -> Self {
+        self.inner.max_opacity4_state_subdivision_level = max_opacity4_state_subdivision_level;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceOpacityMicromapPropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureTrianglesOpacityMicromapEXT.html>"]
+pub struct AccelerationStructureTrianglesOpacityMicromapEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub index_type: IndexType,
+    pub index_buffer: DeviceOrHostAddressConstKHR,
+    pub index_stride: DeviceSize,
+    pub base_triangle: u32,
+    pub usage_counts_count: u32,
+    pub p_usage_counts: *const MicromapUsageEXT,
+    pub pp_usage_counts: *const *const MicromapUsageEXT,
+    pub micromap: MicromapEXT,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for AccelerationStructureTrianglesOpacityMicromapEXT {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("AccelerationStructureTrianglesOpacityMicromapEXT")
+            .field("s_type", &self.s_type)
+            .field("p_next", &self.p_next)
+            .field("index_type", &self.index_type)
+            .field("index_buffer", &"union")
+            .field("index_stride", &self.index_stride)
+            .field("base_triangle", &self.base_triangle)
+            .field("usage_counts_count", &self.usage_counts_count)
+            .field("p_usage_counts", &self.p_usage_counts)
+            .field("pp_usage_counts", &self.pp_usage_counts)
+            .field("micromap", &self.micromap)
+            .finish()
+    }
+}
+impl ::std::default::Default for AccelerationStructureTrianglesOpacityMicromapEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            index_type: IndexType::default(),
+            index_buffer: DeviceOrHostAddressConstKHR::default(),
+            index_stride: DeviceSize::default(),
+            base_triangle: u32::default(),
+            usage_counts_count: u32::default(),
+            p_usage_counts: ::std::ptr::null(),
+            pp_usage_counts: ::std::ptr::null(),
+            micromap: MicromapEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for AccelerationStructureTrianglesOpacityMicromapEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT;
+}
+impl AccelerationStructureTrianglesOpacityMicromapEXT {
+    pub fn builder<'a>() -> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
+        AccelerationStructureTrianglesOpacityMicromapEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
+    inner: AccelerationStructureTrianglesOpacityMicromapEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
+    for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
+    for AccelerationStructureTrianglesOpacityMicromapEXT
+{
+}
+impl<'a> ::std::ops::Deref for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
+    type Target = AccelerationStructureTrianglesOpacityMicromapEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> AccelerationStructureTrianglesOpacityMicromapEXTBuilder<'a> {
+    #[inline]
+    pub fn index_type(mut self, index_type: IndexType) -> Self {
+        self.inner.index_type = index_type;
+        self
+    }
+    #[inline]
+    pub fn index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self {
+        self.inner.index_buffer = index_buffer;
+        self
+    }
+    #[inline]
+    pub fn index_stride(mut self, index_stride: DeviceSize) -> Self {
+        self.inner.index_stride = index_stride;
+        self
+    }
+    #[inline]
+    pub fn base_triangle(mut self, base_triangle: u32) -> Self {
+        self.inner.base_triangle = base_triangle;
+        self
+    }
+    #[inline]
+    pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self {
+        self.inner.usage_counts_count = usage_counts.len() as _;
+        self.inner.p_usage_counts = usage_counts.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self {
+        self.inner.usage_counts_count = usage_counts_ptrs.len() as _;
+        self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast();
+        self
+    }
+    #[inline]
+    pub fn micromap(mut self, micromap: MicromapEXT) -> Self {
+        self.inner.micromap = micromap;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> AccelerationStructureTrianglesOpacityMicromapEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDisplacementMicromapFeaturesNV.html>"]
+pub struct PhysicalDeviceDisplacementMicromapFeaturesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub displacement_micromap: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceDisplacementMicromapFeaturesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            displacement_micromap: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDisplacementMicromapFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV;
+}
+impl PhysicalDeviceDisplacementMicromapFeaturesNV {
+    pub fn builder<'a>() -> PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
+        PhysicalDeviceDisplacementMicromapFeaturesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
+    inner: PhysicalDeviceDisplacementMicromapFeaturesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDisplacementMicromapFeaturesNV {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDisplacementMicromapFeaturesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
+    type Target = PhysicalDeviceDisplacementMicromapFeaturesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDisplacementMicromapFeaturesNVBuilder<'a> {
+    #[inline]
+    pub fn displacement_micromap(mut self, displacement_micromap: bool) -> Self {
+        self.inner.displacement_micromap = displacement_micromap.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDisplacementMicromapFeaturesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDisplacementMicromapPropertiesNV.html>"]
+pub struct PhysicalDeviceDisplacementMicromapPropertiesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub max_displacement_micromap_subdivision_level: u32,
+}
+impl ::std::default::Default for PhysicalDeviceDisplacementMicromapPropertiesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            max_displacement_micromap_subdivision_level: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDisplacementMicromapPropertiesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV;
+}
+impl PhysicalDeviceDisplacementMicromapPropertiesNV {
+    pub fn builder<'a>() -> PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
+        PhysicalDeviceDisplacementMicromapPropertiesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
+    inner: PhysicalDeviceDisplacementMicromapPropertiesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDisplacementMicromapPropertiesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
+    type Target = PhysicalDeviceDisplacementMicromapPropertiesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDisplacementMicromapPropertiesNVBuilder<'a> {
+    #[inline]
+    pub fn max_displacement_micromap_subdivision_level(
+        mut self,
+        max_displacement_micromap_subdivision_level: u32,
+    ) -> Self {
+        self.inner.max_displacement_micromap_subdivision_level =
+            max_displacement_micromap_subdivision_level;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDisplacementMicromapPropertiesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureTrianglesDisplacementMicromapNV.html>"]
+pub struct AccelerationStructureTrianglesDisplacementMicromapNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub displacement_bias_and_scale_format: Format,
+    pub displacement_vector_format: Format,
+    pub displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR,
+    pub displacement_bias_and_scale_stride: DeviceSize,
+    pub displacement_vector_buffer: DeviceOrHostAddressConstKHR,
+    pub displacement_vector_stride: DeviceSize,
+    pub displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR,
+    pub displaced_micromap_primitive_flags_stride: DeviceSize,
+    pub index_type: IndexType,
+    pub index_buffer: DeviceOrHostAddressConstKHR,
+    pub index_stride: DeviceSize,
+    pub base_triangle: u32,
+    pub usage_counts_count: u32,
+    pub p_usage_counts: *const MicromapUsageEXT,
+    pub pp_usage_counts: *const *const MicromapUsageEXT,
+    pub micromap: MicromapEXT,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for AccelerationStructureTrianglesDisplacementMicromapNV {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("AccelerationStructureTrianglesDisplacementMicromapNV")
+            .field("s_type", &self.s_type)
+            .field("p_next", &self.p_next)
+            .field(
+                "displacement_bias_and_scale_format",
+                &self.displacement_bias_and_scale_format,
+            )
+            .field(
+                "displacement_vector_format",
+                &self.displacement_vector_format,
+            )
+            .field("displacement_bias_and_scale_buffer", &"union")
+            .field(
+                "displacement_bias_and_scale_stride",
+                &self.displacement_bias_and_scale_stride,
+            )
+            .field("displacement_vector_buffer", &"union")
+            .field(
+                "displacement_vector_stride",
+                &self.displacement_vector_stride,
+            )
+            .field("displaced_micromap_primitive_flags", &"union")
+            .field(
+                "displaced_micromap_primitive_flags_stride",
+                &self.displaced_micromap_primitive_flags_stride,
+            )
+            .field("index_type", &self.index_type)
+            .field("index_buffer", &"union")
+            .field("index_stride", &self.index_stride)
+            .field("base_triangle", &self.base_triangle)
+            .field("usage_counts_count", &self.usage_counts_count)
+            .field("p_usage_counts", &self.p_usage_counts)
+            .field("pp_usage_counts", &self.pp_usage_counts)
+            .field("micromap", &self.micromap)
+            .finish()
+    }
+}
+impl ::std::default::Default for AccelerationStructureTrianglesDisplacementMicromapNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            displacement_bias_and_scale_format: Format::default(),
+            displacement_vector_format: Format::default(),
+            displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR::default(),
+            displacement_bias_and_scale_stride: DeviceSize::default(),
+            displacement_vector_buffer: DeviceOrHostAddressConstKHR::default(),
+            displacement_vector_stride: DeviceSize::default(),
+            displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR::default(),
+            displaced_micromap_primitive_flags_stride: DeviceSize::default(),
+            index_type: IndexType::default(),
+            index_buffer: DeviceOrHostAddressConstKHR::default(),
+            index_stride: DeviceSize::default(),
+            base_triangle: u32::default(),
+            usage_counts_count: u32::default(),
+            p_usage_counts: ::std::ptr::null(),
+            pp_usage_counts: ::std::ptr::null(),
+            micromap: MicromapEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for AccelerationStructureTrianglesDisplacementMicromapNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV;
+}
+impl AccelerationStructureTrianglesDisplacementMicromapNV {
+    pub fn builder<'a>() -> AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
+        AccelerationStructureTrianglesDisplacementMicromapNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
+    inner: AccelerationStructureTrianglesDisplacementMicromapNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
+    for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'_>
+{
+}
+unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR
+    for AccelerationStructureTrianglesDisplacementMicromapNV
+{
+}
+impl<'a> ::std::ops::Deref for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
+    type Target = AccelerationStructureTrianglesDisplacementMicromapNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> AccelerationStructureTrianglesDisplacementMicromapNVBuilder<'a> {
+    #[inline]
+    pub fn displacement_bias_and_scale_format(
+        mut self,
+        displacement_bias_and_scale_format: Format,
+    ) -> Self {
+        self.inner.displacement_bias_and_scale_format = displacement_bias_and_scale_format;
+        self
+    }
+    #[inline]
+    pub fn displacement_vector_format(mut self, displacement_vector_format: Format) -> Self {
+        self.inner.displacement_vector_format = displacement_vector_format;
+        self
+    }
+    #[inline]
+    pub fn displacement_bias_and_scale_buffer(
+        mut self,
+        displacement_bias_and_scale_buffer: DeviceOrHostAddressConstKHR,
+    ) -> Self {
+        self.inner.displacement_bias_and_scale_buffer = displacement_bias_and_scale_buffer;
+        self
+    }
+    #[inline]
+    pub fn displacement_bias_and_scale_stride(
+        mut self,
+        displacement_bias_and_scale_stride: DeviceSize,
+    ) -> Self {
+        self.inner.displacement_bias_and_scale_stride = displacement_bias_and_scale_stride;
+        self
+    }
+    #[inline]
+    pub fn displacement_vector_buffer(
+        mut self,
+        displacement_vector_buffer: DeviceOrHostAddressConstKHR,
+    ) -> Self {
+        self.inner.displacement_vector_buffer = displacement_vector_buffer;
+        self
+    }
+    #[inline]
+    pub fn displacement_vector_stride(mut self, displacement_vector_stride: DeviceSize) -> Self {
+        self.inner.displacement_vector_stride = displacement_vector_stride;
+        self
+    }
+    #[inline]
+    pub fn displaced_micromap_primitive_flags(
+        mut self,
+        displaced_micromap_primitive_flags: DeviceOrHostAddressConstKHR,
+    ) -> Self {
+        self.inner.displaced_micromap_primitive_flags = displaced_micromap_primitive_flags;
+        self
+    }
+    #[inline]
+    pub fn displaced_micromap_primitive_flags_stride(
+        mut self,
+        displaced_micromap_primitive_flags_stride: DeviceSize,
+    ) -> Self {
+        self.inner.displaced_micromap_primitive_flags_stride =
+            displaced_micromap_primitive_flags_stride;
+        self
+    }
+    #[inline]
+    pub fn index_type(mut self, index_type: IndexType) -> Self {
+        self.inner.index_type = index_type;
+        self
+    }
+    #[inline]
+    pub fn index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self {
+        self.inner.index_buffer = index_buffer;
+        self
+    }
+    #[inline]
+    pub fn index_stride(mut self, index_stride: DeviceSize) -> Self {
+        self.inner.index_stride = index_stride;
+        self
+    }
+    #[inline]
+    pub fn base_triangle(mut self, base_triangle: u32) -> Self {
+        self.inner.base_triangle = base_triangle;
+        self
+    }
+    #[inline]
+    pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self {
+        self.inner.usage_counts_count = usage_counts.len() as _;
+        self.inner.p_usage_counts = usage_counts.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self {
+        self.inner.usage_counts_count = usage_counts_ptrs.len() as _;
+        self.inner.pp_usage_counts = usage_counts_ptrs.as_ptr().cast();
+        self
+    }
+    #[inline]
+    pub fn micromap(mut self, micromap: MicromapEXT) -> Self {
+        self.inner.micromap = micromap;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> AccelerationStructureTrianglesDisplacementMicromapNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelinePropertiesIdentifierEXT.html>"]
+pub struct PipelinePropertiesIdentifierEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub pipeline_identifier: [u8; UUID_SIZE],
+}
+impl ::std::default::Default for PipelinePropertiesIdentifierEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            pipeline_identifier: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for PipelinePropertiesIdentifierEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_PROPERTIES_IDENTIFIER_EXT;
+}
+impl PipelinePropertiesIdentifierEXT {
+    pub fn builder<'a>() -> PipelinePropertiesIdentifierEXTBuilder<'a> {
+        PipelinePropertiesIdentifierEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PipelinePropertiesIdentifierEXTBuilder<'a> {
+    inner: PipelinePropertiesIdentifierEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for PipelinePropertiesIdentifierEXTBuilder<'a> {
+    type Target = PipelinePropertiesIdentifierEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PipelinePropertiesIdentifierEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PipelinePropertiesIdentifierEXTBuilder<'a> {
+    #[inline]
+    pub fn pipeline_identifier(mut self, pipeline_identifier: [u8; UUID_SIZE]) -> Self {
+        self.inner.pipeline_identifier = pipeline_identifier;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PipelinePropertiesIdentifierEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelinePropertiesFeaturesEXT.html>"]
+pub struct PhysicalDevicePipelinePropertiesFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub pipeline_properties_identifier: Bool32,
+}
+impl ::std::default::Default for PhysicalDevicePipelinePropertiesFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            pipeline_properties_identifier: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDevicePipelinePropertiesFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT;
+}
+impl PhysicalDevicePipelinePropertiesFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
+        PhysicalDevicePipelinePropertiesFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
+    inner: PhysicalDevicePipelinePropertiesFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelinePropertiesFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDevicePipelinePropertiesFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDevicePipelinePropertiesFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn pipeline_properties_identifier(mut self, pipeline_properties_identifier: bool) -> Self {
+        self.inner.pipeline_properties_identifier = pipeline_properties_identifier.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDevicePipelinePropertiesFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.html>"]
+pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_early_and_late_fragment_tests: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            shader_early_and_late_fragment_tests: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD;
+}
+impl PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
+    pub fn builder<'a>() -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
+        PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
+    inner: PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
+    type Target = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut
+    for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a>
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMDBuilder<'a> {
+    #[inline]
+    pub fn shader_early_and_late_fragment_tests(
+        mut self,
+        shader_early_and_late_fragment_tests: bool,
+    ) -> Self {
+        self.inner.shader_early_and_late_fragment_tests =
+            shader_early_and_late_fragment_tests.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalObjectCreateInfoEXT.html>"]
+pub struct ExportMetalObjectCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub export_object_type: ExportMetalObjectTypeFlagsEXT,
+}
+impl ::std::default::Default for ExportMetalObjectCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            export_object_type: ExportMetalObjectTypeFlagsEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ExportMetalObjectCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECT_CREATE_INFO_EXT;
+}
+impl ExportMetalObjectCreateInfoEXT {
+    pub fn builder<'a>() -> ExportMetalObjectCreateInfoEXTBuilder<'a> {
+        ExportMetalObjectCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ExportMetalObjectCreateInfoEXTBuilder<'a> {
+    inner: ExportMetalObjectCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXT {}
+unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXT {}
+unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXT {}
+unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXT {}
+unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXT {}
+unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXT {}
+unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for ExportMetalObjectCreateInfoEXTBuilder<'a> {
+    type Target = ExportMetalObjectCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ExportMetalObjectCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ExportMetalObjectCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn export_object_type(mut self, export_object_type: ExportMetalObjectTypeFlagsEXT) -> Self {
+        self.inner.export_object_type = export_object_type;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ExportMetalObjectCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalObjectsInfoEXT.html>"]
+pub struct ExportMetalObjectsInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+}
+impl ::std::default::Default for ExportMetalObjectsInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ExportMetalObjectsInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECTS_INFO_EXT;
+}
+impl ExportMetalObjectsInfoEXT {
+    pub fn builder<'a>() -> ExportMetalObjectsInfoEXTBuilder<'a> {
+        ExportMetalObjectsInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ExportMetalObjectsInfoEXTBuilder<'a> {
+    inner: ExportMetalObjectsInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+pub unsafe trait ExtendsExportMetalObjectsInfoEXT {}
+impl<'a> ::std::ops::Deref for ExportMetalObjectsInfoEXTBuilder<'a> {
+    type Target = ExportMetalObjectsInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ExportMetalObjectsInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ExportMetalObjectsInfoEXTBuilder<'a> {
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsExportMetalObjectsInfoEXT>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ExportMetalObjectsInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalDeviceInfoEXT.html>"]
+pub struct ExportMetalDeviceInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub mtl_device: MTLDevice_id,
+}
+impl ::std::default::Default for ExportMetalDeviceInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            mtl_device: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ExportMetalDeviceInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_DEVICE_INFO_EXT;
+}
+impl ExportMetalDeviceInfoEXT {
+    pub fn builder<'a>() -> ExportMetalDeviceInfoEXTBuilder<'a> {
+        ExportMetalDeviceInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ExportMetalDeviceInfoEXTBuilder<'a> {
+    inner: ExportMetalDeviceInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXTBuilder<'_> {}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXT {}
+impl<'a> ::std::ops::Deref for ExportMetalDeviceInfoEXTBuilder<'a> {
+    type Target = ExportMetalDeviceInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ExportMetalDeviceInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ExportMetalDeviceInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn mtl_device(mut self, mtl_device: MTLDevice_id) -> Self {
+        self.inner.mtl_device = mtl_device;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ExportMetalDeviceInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalCommandQueueInfoEXT.html>"]
+pub struct ExportMetalCommandQueueInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub queue: Queue,
+    pub mtl_command_queue: MTLCommandQueue_id,
+}
+impl ::std::default::Default for ExportMetalCommandQueueInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            queue: Queue::default(),
+            mtl_command_queue: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ExportMetalCommandQueueInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT;
+}
+impl ExportMetalCommandQueueInfoEXT {
+    pub fn builder<'a>() -> ExportMetalCommandQueueInfoEXTBuilder<'a> {
+        ExportMetalCommandQueueInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ExportMetalCommandQueueInfoEXTBuilder<'a> {
+    inner: ExportMetalCommandQueueInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXTBuilder<'_> {}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXT {}
+impl<'a> ::std::ops::Deref for ExportMetalCommandQueueInfoEXTBuilder<'a> {
+    type Target = ExportMetalCommandQueueInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ExportMetalCommandQueueInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ExportMetalCommandQueueInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn queue(mut self, queue: Queue) -> Self {
+        self.inner.queue = queue;
+        self
+    }
+    #[inline]
+    pub fn mtl_command_queue(mut self, mtl_command_queue: MTLCommandQueue_id) -> Self {
+        self.inner.mtl_command_queue = mtl_command_queue;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ExportMetalCommandQueueInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalBufferInfoEXT.html>"]
+pub struct ExportMetalBufferInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub memory: DeviceMemory,
+    pub mtl_buffer: MTLBuffer_id,
+}
+impl ::std::default::Default for ExportMetalBufferInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            memory: DeviceMemory::default(),
+            mtl_buffer: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ExportMetalBufferInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_BUFFER_INFO_EXT;
+}
+impl ExportMetalBufferInfoEXT {
+    pub fn builder<'a>() -> ExportMetalBufferInfoEXTBuilder<'a> {
+        ExportMetalBufferInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ExportMetalBufferInfoEXTBuilder<'a> {
+    inner: ExportMetalBufferInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXTBuilder<'_> {}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXT {}
+impl<'a> ::std::ops::Deref for ExportMetalBufferInfoEXTBuilder<'a> {
+    type Target = ExportMetalBufferInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ExportMetalBufferInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ExportMetalBufferInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn memory(mut self, memory: DeviceMemory) -> Self {
+        self.inner.memory = memory;
+        self
+    }
+    #[inline]
+    pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self {
+        self.inner.mtl_buffer = mtl_buffer;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ExportMetalBufferInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalBufferInfoEXT.html>"]
+pub struct ImportMetalBufferInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub mtl_buffer: MTLBuffer_id,
+}
+impl ::std::default::Default for ImportMetalBufferInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            mtl_buffer: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ImportMetalBufferInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_BUFFER_INFO_EXT;
+}
+impl ImportMetalBufferInfoEXT {
+    pub fn builder<'a>() -> ImportMetalBufferInfoEXTBuilder<'a> {
+        ImportMetalBufferInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImportMetalBufferInfoEXTBuilder<'a> {
+    inner: ImportMetalBufferInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXTBuilder<'_> {}
+unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXT {}
+impl<'a> ::std::ops::Deref for ImportMetalBufferInfoEXTBuilder<'a> {
+    type Target = ImportMetalBufferInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImportMetalBufferInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImportMetalBufferInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self {
+        self.inner.mtl_buffer = mtl_buffer;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImportMetalBufferInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalTextureInfoEXT.html>"]
+pub struct ExportMetalTextureInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub image: Image,
+    pub image_view: ImageView,
+    pub buffer_view: BufferView,
+    pub plane: ImageAspectFlags,
+    pub mtl_texture: MTLTexture_id,
+}
+impl ::std::default::Default for ExportMetalTextureInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            image: Image::default(),
+            image_view: ImageView::default(),
+            buffer_view: BufferView::default(),
+            plane: ImageAspectFlags::default(),
+            mtl_texture: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ExportMetalTextureInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_TEXTURE_INFO_EXT;
+}
+impl ExportMetalTextureInfoEXT {
+    pub fn builder<'a>() -> ExportMetalTextureInfoEXTBuilder<'a> {
+        ExportMetalTextureInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ExportMetalTextureInfoEXTBuilder<'a> {
+    inner: ExportMetalTextureInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXTBuilder<'_> {}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXT {}
+impl<'a> ::std::ops::Deref for ExportMetalTextureInfoEXTBuilder<'a> {
+    type Target = ExportMetalTextureInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ExportMetalTextureInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ExportMetalTextureInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn image(mut self, image: Image) -> Self {
+        self.inner.image = image;
+        self
+    }
+    #[inline]
+    pub fn image_view(mut self, image_view: ImageView) -> Self {
+        self.inner.image_view = image_view;
+        self
+    }
+    #[inline]
+    pub fn buffer_view(mut self, buffer_view: BufferView) -> Self {
+        self.inner.buffer_view = buffer_view;
+        self
+    }
+    #[inline]
+    pub fn plane(mut self, plane: ImageAspectFlags) -> Self {
+        self.inner.plane = plane;
+        self
+    }
+    #[inline]
+    pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self {
+        self.inner.mtl_texture = mtl_texture;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ExportMetalTextureInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalTextureInfoEXT.html>"]
+pub struct ImportMetalTextureInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub plane: ImageAspectFlags,
+    pub mtl_texture: MTLTexture_id,
+}
+impl ::std::default::Default for ImportMetalTextureInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            plane: ImageAspectFlags::default(),
+            mtl_texture: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ImportMetalTextureInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_TEXTURE_INFO_EXT;
+}
+impl ImportMetalTextureInfoEXT {
+    pub fn builder<'a>() -> ImportMetalTextureInfoEXTBuilder<'a> {
+        ImportMetalTextureInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImportMetalTextureInfoEXTBuilder<'a> {
+    inner: ImportMetalTextureInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXTBuilder<'_> {}
+unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXT {}
+impl<'a> ::std::ops::Deref for ImportMetalTextureInfoEXTBuilder<'a> {
+    type Target = ImportMetalTextureInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImportMetalTextureInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImportMetalTextureInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn plane(mut self, plane: ImageAspectFlags) -> Self {
+        self.inner.plane = plane;
+        self
+    }
+    #[inline]
+    pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self {
+        self.inner.mtl_texture = mtl_texture;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImportMetalTextureInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalIOSurfaceInfoEXT.html>"]
+pub struct ExportMetalIOSurfaceInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub image: Image,
+    pub io_surface: IOSurfaceRef,
+}
+impl ::std::default::Default for ExportMetalIOSurfaceInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            image: Image::default(),
+            io_surface: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ExportMetalIOSurfaceInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_IO_SURFACE_INFO_EXT;
+}
+impl ExportMetalIOSurfaceInfoEXT {
+    pub fn builder<'a>() -> ExportMetalIOSurfaceInfoEXTBuilder<'a> {
+        ExportMetalIOSurfaceInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ExportMetalIOSurfaceInfoEXTBuilder<'a> {
+    inner: ExportMetalIOSurfaceInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXTBuilder<'_> {}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXT {}
+impl<'a> ::std::ops::Deref for ExportMetalIOSurfaceInfoEXTBuilder<'a> {
+    type Target = ExportMetalIOSurfaceInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ExportMetalIOSurfaceInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ExportMetalIOSurfaceInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn image(mut self, image: Image) -> Self {
+        self.inner.image = image;
+        self
+    }
+    #[inline]
+    pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self {
+        self.inner.io_surface = io_surface;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ExportMetalIOSurfaceInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalIOSurfaceInfoEXT.html>"]
+pub struct ImportMetalIOSurfaceInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub io_surface: IOSurfaceRef,
+}
+impl ::std::default::Default for ImportMetalIOSurfaceInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            io_surface: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ImportMetalIOSurfaceInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_IO_SURFACE_INFO_EXT;
+}
+impl ImportMetalIOSurfaceInfoEXT {
+    pub fn builder<'a>() -> ImportMetalIOSurfaceInfoEXTBuilder<'a> {
+        ImportMetalIOSurfaceInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImportMetalIOSurfaceInfoEXTBuilder<'a> {
+    inner: ImportMetalIOSurfaceInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXTBuilder<'_> {}
+unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXT {}
+impl<'a> ::std::ops::Deref for ImportMetalIOSurfaceInfoEXTBuilder<'a> {
+    type Target = ImportMetalIOSurfaceInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImportMetalIOSurfaceInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImportMetalIOSurfaceInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self {
+        self.inner.io_surface = io_surface;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImportMetalIOSurfaceInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkExportMetalSharedEventInfoEXT.html>"]
+pub struct ExportMetalSharedEventInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub semaphore: Semaphore,
+    pub event: Event,
+    pub mtl_shared_event: MTLSharedEvent_id,
+}
+impl ::std::default::Default for ExportMetalSharedEventInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            semaphore: Semaphore::default(),
+            event: Event::default(),
+            mtl_shared_event: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ExportMetalSharedEventInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_SHARED_EVENT_INFO_EXT;
+}
+impl ExportMetalSharedEventInfoEXT {
+    pub fn builder<'a>() -> ExportMetalSharedEventInfoEXTBuilder<'a> {
+        ExportMetalSharedEventInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ExportMetalSharedEventInfoEXTBuilder<'a> {
+    inner: ExportMetalSharedEventInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXTBuilder<'_> {}
+unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXT {}
+impl<'a> ::std::ops::Deref for ExportMetalSharedEventInfoEXTBuilder<'a> {
+    type Target = ExportMetalSharedEventInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ExportMetalSharedEventInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ExportMetalSharedEventInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn semaphore(mut self, semaphore: Semaphore) -> Self {
+        self.inner.semaphore = semaphore;
+        self
+    }
+    #[inline]
+    pub fn event(mut self, event: Event) -> Self {
+        self.inner.event = event;
+        self
+    }
+    #[inline]
+    pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self {
+        self.inner.mtl_shared_event = mtl_shared_event;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ExportMetalSharedEventInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImportMetalSharedEventInfoEXT.html>"]
+pub struct ImportMetalSharedEventInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub mtl_shared_event: MTLSharedEvent_id,
+}
+impl ::std::default::Default for ImportMetalSharedEventInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            mtl_shared_event: unsafe { ::std::mem::zeroed() },
+        }
+    }
+}
+unsafe impl TaggedStructure for ImportMetalSharedEventInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_SHARED_EVENT_INFO_EXT;
+}
+impl ImportMetalSharedEventInfoEXT {
+    pub fn builder<'a>() -> ImportMetalSharedEventInfoEXTBuilder<'a> {
+        ImportMetalSharedEventInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImportMetalSharedEventInfoEXTBuilder<'a> {
+    inner: ImportMetalSharedEventInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {}
+unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXT {}
+unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXTBuilder<'_> {}
+unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXT {}
+impl<'a> ::std::ops::Deref for ImportMetalSharedEventInfoEXTBuilder<'a> {
+    type Target = ImportMetalSharedEventInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImportMetalSharedEventInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImportMetalSharedEventInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self {
+        self.inner.mtl_shared_event = mtl_shared_event;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImportMetalSharedEventInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.html>"]
+pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub non_seamless_cube_map: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            non_seamless_cube_map: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT;
+}
+impl PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
+        PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceNonSeamlessCubeMapFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceNonSeamlessCubeMapFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn non_seamless_cube_map(mut self, non_seamless_cube_map: bool) -> Self {
+        self.inner.non_seamless_cube_map = non_seamless_cube_map.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineRobustnessFeaturesEXT.html>"]
+pub struct PhysicalDevicePipelineRobustnessFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub pipeline_robustness: Bool32,
+}
+impl ::std::default::Default for PhysicalDevicePipelineRobustnessFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            pipeline_robustness: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDevicePipelineRobustnessFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT;
+}
+impl PhysicalDevicePipelineRobustnessFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
+        PhysicalDevicePipelineRobustnessFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
+    inner: PhysicalDevicePipelineRobustnessFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineRobustnessFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDevicePipelineRobustnessFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDevicePipelineRobustnessFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn pipeline_robustness(mut self, pipeline_robustness: bool) -> Self {
+        self.inner.pipeline_robustness = pipeline_robustness.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDevicePipelineRobustnessFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRobustnessCreateInfoEXT.html>"]
+pub struct PipelineRobustnessCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub storage_buffers: PipelineRobustnessBufferBehaviorEXT,
+    pub uniform_buffers: PipelineRobustnessBufferBehaviorEXT,
+    pub vertex_inputs: PipelineRobustnessBufferBehaviorEXT,
+    pub images: PipelineRobustnessImageBehaviorEXT,
+}
+impl ::std::default::Default for PipelineRobustnessCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(),
+            uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(),
+            vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(),
+            images: PipelineRobustnessImageBehaviorEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PipelineRobustnessCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT;
+}
+impl PipelineRobustnessCreateInfoEXT {
+    pub fn builder<'a>() -> PipelineRobustnessCreateInfoEXTBuilder<'a> {
+        PipelineRobustnessCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PipelineRobustnessCreateInfoEXTBuilder<'a> {
+    inner: PipelineRobustnessCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXT {}
+unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXT {}
+unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXT {}
+unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for PipelineRobustnessCreateInfoEXTBuilder<'a> {
+    type Target = PipelineRobustnessCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PipelineRobustnessCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PipelineRobustnessCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn storage_buffers(mut self, storage_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self {
+        self.inner.storage_buffers = storage_buffers;
+        self
+    }
+    #[inline]
+    pub fn uniform_buffers(mut self, uniform_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self {
+        self.inner.uniform_buffers = uniform_buffers;
+        self
+    }
+    #[inline]
+    pub fn vertex_inputs(mut self, vertex_inputs: PipelineRobustnessBufferBehaviorEXT) -> Self {
+        self.inner.vertex_inputs = vertex_inputs;
+        self
+    }
+    #[inline]
+    pub fn images(mut self, images: PipelineRobustnessImageBehaviorEXT) -> Self {
+        self.inner.images = images;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PipelineRobustnessCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineRobustnessPropertiesEXT.html>"]
+pub struct PhysicalDevicePipelineRobustnessPropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT,
+    pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT,
+    pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT,
+    pub default_robustness_images: PipelineRobustnessImageBehaviorEXT,
+}
+impl ::std::default::Default for PhysicalDevicePipelineRobustnessPropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(),
+            default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(),
+            default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(),
+            default_robustness_images: PipelineRobustnessImageBehaviorEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDevicePipelineRobustnessPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT;
+}
+impl PhysicalDevicePipelineRobustnessPropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
+        PhysicalDevicePipelineRobustnessPropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
+    inner: PhysicalDevicePipelineRobustnessPropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePipelineRobustnessPropertiesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
+    type Target = PhysicalDevicePipelineRobustnessPropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDevicePipelineRobustnessPropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn default_robustness_storage_buffers(
+        mut self,
+        default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT,
+    ) -> Self {
+        self.inner.default_robustness_storage_buffers = default_robustness_storage_buffers;
+        self
+    }
+    #[inline]
+    pub fn default_robustness_uniform_buffers(
+        mut self,
+        default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT,
+    ) -> Self {
+        self.inner.default_robustness_uniform_buffers = default_robustness_uniform_buffers;
+        self
+    }
+    #[inline]
+    pub fn default_robustness_vertex_inputs(
+        mut self,
+        default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT,
+    ) -> Self {
+        self.inner.default_robustness_vertex_inputs = default_robustness_vertex_inputs;
+        self
+    }
+    #[inline]
+    pub fn default_robustness_images(
+        mut self,
+        default_robustness_images: PipelineRobustnessImageBehaviorEXT,
+    ) -> Self {
+        self.inner.default_robustness_images = default_robustness_images;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDevicePipelineRobustnessPropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewSampleWeightCreateInfoQCOM.html>"]
+pub struct ImageViewSampleWeightCreateInfoQCOM {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub filter_center: Offset2D,
+    pub filter_size: Extent2D,
+    pub num_phases: u32,
+}
+impl ::std::default::Default for ImageViewSampleWeightCreateInfoQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            filter_center: Offset2D::default(),
+            filter_size: Extent2D::default(),
+            num_phases: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ImageViewSampleWeightCreateInfoQCOM {
+    const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM;
+}
+impl ImageViewSampleWeightCreateInfoQCOM {
+    pub fn builder<'a>() -> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
+        ImageViewSampleWeightCreateInfoQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
+    inner: ImageViewSampleWeightCreateInfoQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOMBuilder<'_> {}
+unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOM {}
+impl<'a> ::std::ops::Deref for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
+    type Target = ImageViewSampleWeightCreateInfoQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ImageViewSampleWeightCreateInfoQCOMBuilder<'a> {
+    #[inline]
+    pub fn filter_center(mut self, filter_center: Offset2D) -> Self {
+        self.inner.filter_center = filter_center;
+        self
+    }
+    #[inline]
+    pub fn filter_size(mut self, filter_size: Extent2D) -> Self {
+        self.inner.filter_size = filter_size;
+        self
+    }
+    #[inline]
+    pub fn num_phases(mut self, num_phases: u32) -> Self {
+        self.inner.num_phases = num_phases;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ImageViewSampleWeightCreateInfoQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageProcessingFeaturesQCOM.html>"]
+pub struct PhysicalDeviceImageProcessingFeaturesQCOM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub texture_sample_weighted: Bool32,
+    pub texture_box_filter: Bool32,
+    pub texture_block_match: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceImageProcessingFeaturesQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            texture_sample_weighted: Bool32::default(),
+            texture_box_filter: Bool32::default(),
+            texture_block_match: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceImageProcessingFeaturesQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM;
+}
+impl PhysicalDeviceImageProcessingFeaturesQCOM {
+    pub fn builder<'a>() -> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
+        PhysicalDeviceImageProcessingFeaturesQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
+    inner: PhysicalDeviceImageProcessingFeaturesQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageProcessingFeaturesQCOM {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOM {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
+    type Target = PhysicalDeviceImageProcessingFeaturesQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceImageProcessingFeaturesQCOMBuilder<'a> {
+    #[inline]
+    pub fn texture_sample_weighted(mut self, texture_sample_weighted: bool) -> Self {
+        self.inner.texture_sample_weighted = texture_sample_weighted.into();
+        self
+    }
+    #[inline]
+    pub fn texture_box_filter(mut self, texture_box_filter: bool) -> Self {
+        self.inner.texture_box_filter = texture_box_filter.into();
+        self
+    }
+    #[inline]
+    pub fn texture_block_match(mut self, texture_block_match: bool) -> Self {
+        self.inner.texture_block_match = texture_block_match.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceImageProcessingFeaturesQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceImageProcessingPropertiesQCOM.html>"]
+pub struct PhysicalDeviceImageProcessingPropertiesQCOM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub max_weight_filter_phases: u32,
+    pub max_weight_filter_dimension: Extent2D,
+    pub max_block_match_region: Extent2D,
+    pub max_box_filter_block_size: Extent2D,
+}
+impl ::std::default::Default for PhysicalDeviceImageProcessingPropertiesQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            max_weight_filter_phases: u32::default(),
+            max_weight_filter_dimension: Extent2D::default(),
+            max_block_match_region: Extent2D::default(),
+            max_box_filter_block_size: Extent2D::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceImageProcessingPropertiesQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM;
+}
+impl PhysicalDeviceImageProcessingPropertiesQCOM {
+    pub fn builder<'a>() -> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
+        PhysicalDeviceImageProcessingPropertiesQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
+    inner: PhysicalDeviceImageProcessingPropertiesQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageProcessingPropertiesQCOM {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
+    type Target = PhysicalDeviceImageProcessingPropertiesQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceImageProcessingPropertiesQCOMBuilder<'a> {
+    #[inline]
+    pub fn max_weight_filter_phases(mut self, max_weight_filter_phases: u32) -> Self {
+        self.inner.max_weight_filter_phases = max_weight_filter_phases;
+        self
+    }
+    #[inline]
+    pub fn max_weight_filter_dimension(mut self, max_weight_filter_dimension: Extent2D) -> Self {
+        self.inner.max_weight_filter_dimension = max_weight_filter_dimension;
+        self
+    }
+    #[inline]
+    pub fn max_block_match_region(mut self, max_block_match_region: Extent2D) -> Self {
+        self.inner.max_block_match_region = max_block_match_region;
+        self
+    }
+    #[inline]
+    pub fn max_box_filter_block_size(mut self, max_box_filter_block_size: Extent2D) -> Self {
+        self.inner.max_box_filter_block_size = max_box_filter_block_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceImageProcessingPropertiesQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceTilePropertiesFeaturesQCOM.html>"]
+pub struct PhysicalDeviceTilePropertiesFeaturesQCOM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub tile_properties: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceTilePropertiesFeaturesQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            tile_properties: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceTilePropertiesFeaturesQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM;
+}
+impl PhysicalDeviceTilePropertiesFeaturesQCOM {
+    pub fn builder<'a>() -> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
+        PhysicalDeviceTilePropertiesFeaturesQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
+    inner: PhysicalDeviceTilePropertiesFeaturesQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOM {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOM {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
+    type Target = PhysicalDeviceTilePropertiesFeaturesQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceTilePropertiesFeaturesQCOMBuilder<'a> {
+    #[inline]
+    pub fn tile_properties(mut self, tile_properties: bool) -> Self {
+        self.inner.tile_properties = tile_properties.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceTilePropertiesFeaturesQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTilePropertiesQCOM.html>"]
+pub struct TilePropertiesQCOM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub tile_size: Extent3D,
+    pub apron_size: Extent2D,
+    pub origin: Offset2D,
+}
+impl ::std::default::Default for TilePropertiesQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            tile_size: Extent3D::default(),
+            apron_size: Extent2D::default(),
+            origin: Offset2D::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for TilePropertiesQCOM {
+    const STRUCTURE_TYPE: StructureType = StructureType::TILE_PROPERTIES_QCOM;
+}
+impl TilePropertiesQCOM {
+    pub fn builder<'a>() -> TilePropertiesQCOMBuilder<'a> {
+        TilePropertiesQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct TilePropertiesQCOMBuilder<'a> {
+    inner: TilePropertiesQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for TilePropertiesQCOMBuilder<'a> {
+    type Target = TilePropertiesQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for TilePropertiesQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> TilePropertiesQCOMBuilder<'a> {
+    #[inline]
+    pub fn tile_size(mut self, tile_size: Extent3D) -> Self {
+        self.inner.tile_size = tile_size;
+        self
+    }
+    #[inline]
+    pub fn apron_size(mut self, apron_size: Extent2D) -> Self {
+        self.inner.apron_size = apron_size;
+        self
+    }
+    #[inline]
+    pub fn origin(mut self, origin: Offset2D) -> Self {
+        self.inner.origin = origin;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> TilePropertiesQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAmigoProfilingFeaturesSEC.html>"]
+pub struct PhysicalDeviceAmigoProfilingFeaturesSEC {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub amigo_profiling: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceAmigoProfilingFeaturesSEC {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            amigo_profiling: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceAmigoProfilingFeaturesSEC {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC;
+}
+impl PhysicalDeviceAmigoProfilingFeaturesSEC {
+    pub fn builder<'a>() -> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
+        PhysicalDeviceAmigoProfilingFeaturesSECBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
+    inner: PhysicalDeviceAmigoProfilingFeaturesSEC,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSEC {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSEC {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
+    type Target = PhysicalDeviceAmigoProfilingFeaturesSEC;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceAmigoProfilingFeaturesSECBuilder<'a> {
+    #[inline]
+    pub fn amigo_profiling(mut self, amigo_profiling: bool) -> Self {
+        self.inner.amigo_profiling = amigo_profiling.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceAmigoProfilingFeaturesSEC {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAmigoProfilingSubmitInfoSEC.html>"]
+pub struct AmigoProfilingSubmitInfoSEC {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub first_draw_timestamp: u64,
+    pub swap_buffer_timestamp: u64,
+}
+impl ::std::default::Default for AmigoProfilingSubmitInfoSEC {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            first_draw_timestamp: u64::default(),
+            swap_buffer_timestamp: u64::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for AmigoProfilingSubmitInfoSEC {
+    const STRUCTURE_TYPE: StructureType = StructureType::AMIGO_PROFILING_SUBMIT_INFO_SEC;
+}
+impl AmigoProfilingSubmitInfoSEC {
+    pub fn builder<'a>() -> AmigoProfilingSubmitInfoSECBuilder<'a> {
+        AmigoProfilingSubmitInfoSECBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct AmigoProfilingSubmitInfoSECBuilder<'a> {
+    inner: AmigoProfilingSubmitInfoSEC,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSECBuilder<'_> {}
+unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSEC {}
+impl<'a> ::std::ops::Deref for AmigoProfilingSubmitInfoSECBuilder<'a> {
+    type Target = AmigoProfilingSubmitInfoSEC;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for AmigoProfilingSubmitInfoSECBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> AmigoProfilingSubmitInfoSECBuilder<'a> {
+    #[inline]
+    pub fn first_draw_timestamp(mut self, first_draw_timestamp: u64) -> Self {
+        self.inner.first_draw_timestamp = first_draw_timestamp;
+        self
+    }
+    #[inline]
+    pub fn swap_buffer_timestamp(mut self, swap_buffer_timestamp: u64) -> Self {
+        self.inner.swap_buffer_timestamp = swap_buffer_timestamp;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> AmigoProfilingSubmitInfoSEC {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.html>"]
+pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub attachment_feedback_loop_layout: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            attachment_feedback_loop_layout: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT;
+}
+impl PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
+        PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn attachment_feedback_loop_layout(
+        mut self,
+        attachment_feedback_loop_layout: bool,
+    ) -> Self {
+        self.inner.attachment_feedback_loop_layout = attachment_feedback_loop_layout.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDepthClampZeroOneFeaturesEXT.html>"]
+pub struct PhysicalDeviceDepthClampZeroOneFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub depth_clamp_zero_one: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceDepthClampZeroOneFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            depth_clamp_zero_one: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDepthClampZeroOneFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT;
+}
+impl PhysicalDeviceDepthClampZeroOneFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
+        PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceDepthClampZeroOneFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClampZeroOneFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceDepthClampZeroOneFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDepthClampZeroOneFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn depth_clamp_zero_one(mut self, depth_clamp_zero_one: bool) -> Self {
+        self.inner.depth_clamp_zero_one = depth_clamp_zero_one.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDepthClampZeroOneFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceAddressBindingReportFeaturesEXT.html>"]
+pub struct PhysicalDeviceAddressBindingReportFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub report_address_binding: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceAddressBindingReportFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            report_address_binding: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceAddressBindingReportFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT;
+}
+impl PhysicalDeviceAddressBindingReportFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
+        PhysicalDeviceAddressBindingReportFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceAddressBindingReportFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAddressBindingReportFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceAddressBindingReportFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceAddressBindingReportFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn report_address_binding(mut self, report_address_binding: bool) -> Self {
+        self.inner.report_address_binding = report_address_binding.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceAddressBindingReportFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddressBindingCallbackDataEXT.html>"]
+pub struct DeviceAddressBindingCallbackDataEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub flags: DeviceAddressBindingFlagsEXT,
+    pub base_address: DeviceAddress,
+    pub size: DeviceSize,
+    pub binding_type: DeviceAddressBindingTypeEXT,
+}
+impl ::std::default::Default for DeviceAddressBindingCallbackDataEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            flags: DeviceAddressBindingFlagsEXT::default(),
+            base_address: DeviceAddress::default(),
+            size: DeviceSize::default(),
+            binding_type: DeviceAddressBindingTypeEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DeviceAddressBindingCallbackDataEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT;
+}
+impl DeviceAddressBindingCallbackDataEXT {
+    pub fn builder<'a>() -> DeviceAddressBindingCallbackDataEXTBuilder<'a> {
+        DeviceAddressBindingCallbackDataEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DeviceAddressBindingCallbackDataEXTBuilder<'a> {
+    inner: DeviceAddressBindingCallbackDataEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT
+    for DeviceAddressBindingCallbackDataEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT for DeviceAddressBindingCallbackDataEXT {}
+impl<'a> ::std::ops::Deref for DeviceAddressBindingCallbackDataEXTBuilder<'a> {
+    type Target = DeviceAddressBindingCallbackDataEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DeviceAddressBindingCallbackDataEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DeviceAddressBindingCallbackDataEXTBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: DeviceAddressBindingFlagsEXT) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn base_address(mut self, base_address: DeviceAddress) -> Self {
+        self.inner.base_address = base_address;
+        self
+    }
+    #[inline]
+    pub fn size(mut self, size: DeviceSize) -> Self {
+        self.inner.size = size;
+        self
+    }
+    #[inline]
+    pub fn binding_type(mut self, binding_type: DeviceAddressBindingTypeEXT) -> Self {
+        self.inner.binding_type = binding_type;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DeviceAddressBindingCallbackDataEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpticalFlowFeaturesNV.html>"]
+pub struct PhysicalDeviceOpticalFlowFeaturesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub optical_flow: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceOpticalFlowFeaturesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            optical_flow: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceOpticalFlowFeaturesNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV;
+}
+impl PhysicalDeviceOpticalFlowFeaturesNV {
+    pub fn builder<'a>() -> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
+        PhysicalDeviceOpticalFlowFeaturesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
+    inner: PhysicalDeviceOpticalFlowFeaturesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNV {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
+    type Target = PhysicalDeviceOpticalFlowFeaturesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceOpticalFlowFeaturesNVBuilder<'a> {
+    #[inline]
+    pub fn optical_flow(mut self, optical_flow: bool) -> Self {
+        self.inner.optical_flow = optical_flow.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceOpticalFlowFeaturesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceOpticalFlowPropertiesNV.html>"]
+pub struct PhysicalDeviceOpticalFlowPropertiesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV,
+    pub supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV,
+    pub hint_supported: Bool32,
+    pub cost_supported: Bool32,
+    pub bidirectional_flow_supported: Bool32,
+    pub global_flow_supported: Bool32,
+    pub min_width: u32,
+    pub min_height: u32,
+    pub max_width: u32,
+    pub max_height: u32,
+    pub max_num_regions_of_interest: u32,
+}
+impl ::std::default::Default for PhysicalDeviceOpticalFlowPropertiesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV::default(),
+            supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV::default(),
+            hint_supported: Bool32::default(),
+            cost_supported: Bool32::default(),
+            bidirectional_flow_supported: Bool32::default(),
+            global_flow_supported: Bool32::default(),
+            min_width: u32::default(),
+            min_height: u32::default(),
+            max_width: u32::default(),
+            max_height: u32::default(),
+            max_num_regions_of_interest: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceOpticalFlowPropertiesNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV;
+}
+impl PhysicalDeviceOpticalFlowPropertiesNV {
+    pub fn builder<'a>() -> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
+        PhysicalDeviceOpticalFlowPropertiesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
+    inner: PhysicalDeviceOpticalFlowPropertiesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
+    type Target = PhysicalDeviceOpticalFlowPropertiesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceOpticalFlowPropertiesNVBuilder<'a> {
+    #[inline]
+    pub fn supported_output_grid_sizes(
+        mut self,
+        supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV,
+    ) -> Self {
+        self.inner.supported_output_grid_sizes = supported_output_grid_sizes;
+        self
+    }
+    #[inline]
+    pub fn supported_hint_grid_sizes(
+        mut self,
+        supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV,
+    ) -> Self {
+        self.inner.supported_hint_grid_sizes = supported_hint_grid_sizes;
+        self
+    }
+    #[inline]
+    pub fn hint_supported(mut self, hint_supported: bool) -> Self {
+        self.inner.hint_supported = hint_supported.into();
+        self
+    }
+    #[inline]
+    pub fn cost_supported(mut self, cost_supported: bool) -> Self {
+        self.inner.cost_supported = cost_supported.into();
+        self
+    }
+    #[inline]
+    pub fn bidirectional_flow_supported(mut self, bidirectional_flow_supported: bool) -> Self {
+        self.inner.bidirectional_flow_supported = bidirectional_flow_supported.into();
+        self
+    }
+    #[inline]
+    pub fn global_flow_supported(mut self, global_flow_supported: bool) -> Self {
+        self.inner.global_flow_supported = global_flow_supported.into();
+        self
+    }
+    #[inline]
+    pub fn min_width(mut self, min_width: u32) -> Self {
+        self.inner.min_width = min_width;
+        self
+    }
+    #[inline]
+    pub fn min_height(mut self, min_height: u32) -> Self {
+        self.inner.min_height = min_height;
+        self
+    }
+    #[inline]
+    pub fn max_width(mut self, max_width: u32) -> Self {
+        self.inner.max_width = max_width;
+        self
+    }
+    #[inline]
+    pub fn max_height(mut self, max_height: u32) -> Self {
+        self.inner.max_height = max_height;
+        self
+    }
+    #[inline]
+    pub fn max_num_regions_of_interest(mut self, max_num_regions_of_interest: u32) -> Self {
+        self.inner.max_num_regions_of_interest = max_num_regions_of_interest;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceOpticalFlowPropertiesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowImageFormatInfoNV.html>"]
+pub struct OpticalFlowImageFormatInfoNV {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub usage: OpticalFlowUsageFlagsNV,
+}
+impl ::std::default::Default for OpticalFlowImageFormatInfoNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            usage: OpticalFlowUsageFlagsNV::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for OpticalFlowImageFormatInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV;
+}
+impl OpticalFlowImageFormatInfoNV {
+    pub fn builder<'a>() -> OpticalFlowImageFormatInfoNVBuilder<'a> {
+        OpticalFlowImageFormatInfoNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct OpticalFlowImageFormatInfoNVBuilder<'a> {
+    inner: OpticalFlowImageFormatInfoNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNVBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNV {}
+unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNVBuilder<'_> {}
+unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNV {}
+impl<'a> ::std::ops::Deref for OpticalFlowImageFormatInfoNVBuilder<'a> {
+    type Target = OpticalFlowImageFormatInfoNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for OpticalFlowImageFormatInfoNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> OpticalFlowImageFormatInfoNVBuilder<'a> {
+    #[inline]
+    pub fn usage(mut self, usage: OpticalFlowUsageFlagsNV) -> Self {
+        self.inner.usage = usage;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> OpticalFlowImageFormatInfoNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowImageFormatPropertiesNV.html>"]
+pub struct OpticalFlowImageFormatPropertiesNV {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub format: Format,
+}
+impl ::std::default::Default for OpticalFlowImageFormatPropertiesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            format: Format::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for OpticalFlowImageFormatPropertiesNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV;
+}
+impl OpticalFlowImageFormatPropertiesNV {
+    pub fn builder<'a>() -> OpticalFlowImageFormatPropertiesNVBuilder<'a> {
+        OpticalFlowImageFormatPropertiesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct OpticalFlowImageFormatPropertiesNVBuilder<'a> {
+    inner: OpticalFlowImageFormatPropertiesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for OpticalFlowImageFormatPropertiesNVBuilder<'a> {
+    type Target = OpticalFlowImageFormatPropertiesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for OpticalFlowImageFormatPropertiesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> OpticalFlowImageFormatPropertiesNVBuilder<'a> {
+    #[inline]
+    pub fn format(mut self, format: Format) -> Self {
+        self.inner.format = format;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> OpticalFlowImageFormatPropertiesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionCreateInfoNV.html>"]
+pub struct OpticalFlowSessionCreateInfoNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub width: u32,
+    pub height: u32,
+    pub image_format: Format,
+    pub flow_vector_format: Format,
+    pub cost_format: Format,
+    pub output_grid_size: OpticalFlowGridSizeFlagsNV,
+    pub hint_grid_size: OpticalFlowGridSizeFlagsNV,
+    pub performance_level: OpticalFlowPerformanceLevelNV,
+    pub flags: OpticalFlowSessionCreateFlagsNV,
+}
+impl ::std::default::Default for OpticalFlowSessionCreateInfoNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            width: u32::default(),
+            height: u32::default(),
+            image_format: Format::default(),
+            flow_vector_format: Format::default(),
+            cost_format: Format::default(),
+            output_grid_size: OpticalFlowGridSizeFlagsNV::default(),
+            hint_grid_size: OpticalFlowGridSizeFlagsNV::default(),
+            performance_level: OpticalFlowPerformanceLevelNV::default(),
+            flags: OpticalFlowSessionCreateFlagsNV::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for OpticalFlowSessionCreateInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_SESSION_CREATE_INFO_NV;
+}
+impl OpticalFlowSessionCreateInfoNV {
+    pub fn builder<'a>() -> OpticalFlowSessionCreateInfoNVBuilder<'a> {
+        OpticalFlowSessionCreateInfoNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct OpticalFlowSessionCreateInfoNVBuilder<'a> {
+    inner: OpticalFlowSessionCreateInfoNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+pub unsafe trait ExtendsOpticalFlowSessionCreateInfoNV {}
+impl<'a> ::std::ops::Deref for OpticalFlowSessionCreateInfoNVBuilder<'a> {
+    type Target = OpticalFlowSessionCreateInfoNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for OpticalFlowSessionCreateInfoNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> OpticalFlowSessionCreateInfoNVBuilder<'a> {
+    #[inline]
+    pub fn width(mut self, width: u32) -> Self {
+        self.inner.width = width;
+        self
+    }
+    #[inline]
+    pub fn height(mut self, height: u32) -> Self {
+        self.inner.height = height;
+        self
+    }
+    #[inline]
+    pub fn image_format(mut self, image_format: Format) -> Self {
+        self.inner.image_format = image_format;
+        self
+    }
+    #[inline]
+    pub fn flow_vector_format(mut self, flow_vector_format: Format) -> Self {
+        self.inner.flow_vector_format = flow_vector_format;
+        self
+    }
+    #[inline]
+    pub fn cost_format(mut self, cost_format: Format) -> Self {
+        self.inner.cost_format = cost_format;
+        self
+    }
+    #[inline]
+    pub fn output_grid_size(mut self, output_grid_size: OpticalFlowGridSizeFlagsNV) -> Self {
+        self.inner.output_grid_size = output_grid_size;
+        self
+    }
+    #[inline]
+    pub fn hint_grid_size(mut self, hint_grid_size: OpticalFlowGridSizeFlagsNV) -> Self {
+        self.inner.hint_grid_size = hint_grid_size;
+        self
+    }
+    #[inline]
+    pub fn performance_level(mut self, performance_level: OpticalFlowPerformanceLevelNV) -> Self {
+        self.inner.performance_level = performance_level;
+        self
+    }
+    #[inline]
+    pub fn flags(mut self, flags: OpticalFlowSessionCreateFlagsNV) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsOpticalFlowSessionCreateInfoNV>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*mut T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> OpticalFlowSessionCreateInfoNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionCreatePrivateDataInfoNV.html>"]
+pub struct OpticalFlowSessionCreatePrivateDataInfoNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub id: u32,
+    pub size: u32,
+    pub p_private_data: *const c_void,
+}
+impl ::std::default::Default for OpticalFlowSessionCreatePrivateDataInfoNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            id: u32::default(),
+            size: u32::default(),
+            p_private_data: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for OpticalFlowSessionCreatePrivateDataInfoNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV;
+}
+impl OpticalFlowSessionCreatePrivateDataInfoNV {
+    pub fn builder<'a>() -> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
+        OpticalFlowSessionCreatePrivateDataInfoNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
+    inner: OpticalFlowSessionCreatePrivateDataInfoNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsOpticalFlowSessionCreateInfoNV
+    for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'_>
+{
+}
+unsafe impl ExtendsOpticalFlowSessionCreateInfoNV for OpticalFlowSessionCreatePrivateDataInfoNV {}
+impl<'a> ::std::ops::Deref for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
+    type Target = OpticalFlowSessionCreatePrivateDataInfoNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> OpticalFlowSessionCreatePrivateDataInfoNVBuilder<'a> {
+    #[inline]
+    pub fn id(mut self, id: u32) -> Self {
+        self.inner.id = id;
+        self
+    }
+    #[inline]
+    pub fn size(mut self, size: u32) -> Self {
+        self.inner.size = size;
+        self
+    }
+    #[inline]
+    pub fn private_data(mut self, private_data: *const c_void) -> Self {
+        self.inner.p_private_data = private_data;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> OpticalFlowSessionCreatePrivateDataInfoNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowExecuteInfoNV.html>"]
+pub struct OpticalFlowExecuteInfoNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub flags: OpticalFlowExecuteFlagsNV,
+    pub region_count: u32,
+    pub p_regions: *const Rect2D,
+}
+impl ::std::default::Default for OpticalFlowExecuteInfoNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            flags: OpticalFlowExecuteFlagsNV::default(),
+            region_count: u32::default(),
+            p_regions: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for OpticalFlowExecuteInfoNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_EXECUTE_INFO_NV;
+}
+impl OpticalFlowExecuteInfoNV {
+    pub fn builder<'a>() -> OpticalFlowExecuteInfoNVBuilder<'a> {
+        OpticalFlowExecuteInfoNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct OpticalFlowExecuteInfoNVBuilder<'a> {
+    inner: OpticalFlowExecuteInfoNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for OpticalFlowExecuteInfoNVBuilder<'a> {
+    type Target = OpticalFlowExecuteInfoNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for OpticalFlowExecuteInfoNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> OpticalFlowExecuteInfoNVBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: OpticalFlowExecuteFlagsNV) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn regions(mut self, regions: &'a [Rect2D]) -> Self {
+        self.inner.region_count = regions.len() as _;
+        self.inner.p_regions = regions.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> OpticalFlowExecuteInfoNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceFaultFeaturesEXT.html>"]
+pub struct PhysicalDeviceFaultFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub device_fault: Bool32,
+    pub device_fault_vendor_binary: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceFaultFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            device_fault: Bool32::default(),
+            device_fault_vendor_binary: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceFaultFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_EXT;
+}
+impl PhysicalDeviceFaultFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
+        PhysicalDeviceFaultFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceFaultFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceFaultFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceFaultFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn device_fault(mut self, device_fault: bool) -> Self {
+        self.inner.device_fault = device_fault.into();
+        self
+    }
+    #[inline]
+    pub fn device_fault_vendor_binary(mut self, device_fault_vendor_binary: bool) -> Self {
+        self.inner.device_fault_vendor_binary = device_fault_vendor_binary.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceFaultFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultAddressInfoEXT.html>"]
+pub struct DeviceFaultAddressInfoEXT {
+    pub address_type: DeviceFaultAddressTypeEXT,
+    pub reported_address: DeviceAddress,
+    pub address_precision: DeviceSize,
+}
+impl DeviceFaultAddressInfoEXT {
+    pub fn builder<'a>() -> DeviceFaultAddressInfoEXTBuilder<'a> {
+        DeviceFaultAddressInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DeviceFaultAddressInfoEXTBuilder<'a> {
+    inner: DeviceFaultAddressInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DeviceFaultAddressInfoEXTBuilder<'a> {
+    type Target = DeviceFaultAddressInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DeviceFaultAddressInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DeviceFaultAddressInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn address_type(mut self, address_type: DeviceFaultAddressTypeEXT) -> Self {
+        self.inner.address_type = address_type;
+        self
+    }
+    #[inline]
+    pub fn reported_address(mut self, reported_address: DeviceAddress) -> Self {
+        self.inner.reported_address = reported_address;
+        self
+    }
+    #[inline]
+    pub fn address_precision(mut self, address_precision: DeviceSize) -> Self {
+        self.inner.address_precision = address_precision;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DeviceFaultAddressInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultVendorInfoEXT.html>"]
+pub struct DeviceFaultVendorInfoEXT {
+    pub description: [c_char; MAX_DESCRIPTION_SIZE],
+    pub vendor_fault_code: u64,
+    pub vendor_fault_data: u64,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for DeviceFaultVendorInfoEXT {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("DeviceFaultVendorInfoEXT")
+            .field("description", &unsafe {
+                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
+            })
+            .field("vendor_fault_code", &self.vendor_fault_code)
+            .field("vendor_fault_data", &self.vendor_fault_data)
+            .finish()
+    }
+}
+impl ::std::default::Default for DeviceFaultVendorInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            description: unsafe { ::std::mem::zeroed() },
+            vendor_fault_code: u64::default(),
+            vendor_fault_data: u64::default(),
+        }
+    }
+}
+impl DeviceFaultVendorInfoEXT {
+    pub fn builder<'a>() -> DeviceFaultVendorInfoEXTBuilder<'a> {
+        DeviceFaultVendorInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DeviceFaultVendorInfoEXTBuilder<'a> {
+    inner: DeviceFaultVendorInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DeviceFaultVendorInfoEXTBuilder<'a> {
+    type Target = DeviceFaultVendorInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DeviceFaultVendorInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DeviceFaultVendorInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
+        self.inner.description = description;
+        self
+    }
+    #[inline]
+    pub fn vendor_fault_code(mut self, vendor_fault_code: u64) -> Self {
+        self.inner.vendor_fault_code = vendor_fault_code;
+        self
+    }
+    #[inline]
+    pub fn vendor_fault_data(mut self, vendor_fault_data: u64) -> Self {
+        self.inner.vendor_fault_data = vendor_fault_data;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DeviceFaultVendorInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultCountsEXT.html>"]
+pub struct DeviceFaultCountsEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub address_info_count: u32,
+    pub vendor_info_count: u32,
+    pub vendor_binary_size: DeviceSize,
+}
+impl ::std::default::Default for DeviceFaultCountsEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            address_info_count: u32::default(),
+            vendor_info_count: u32::default(),
+            vendor_binary_size: DeviceSize::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DeviceFaultCountsEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_COUNTS_EXT;
+}
+impl DeviceFaultCountsEXT {
+    pub fn builder<'a>() -> DeviceFaultCountsEXTBuilder<'a> {
+        DeviceFaultCountsEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DeviceFaultCountsEXTBuilder<'a> {
+    inner: DeviceFaultCountsEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DeviceFaultCountsEXTBuilder<'a> {
+    type Target = DeviceFaultCountsEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DeviceFaultCountsEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DeviceFaultCountsEXTBuilder<'a> {
+    #[inline]
+    pub fn address_info_count(mut self, address_info_count: u32) -> Self {
+        self.inner.address_info_count = address_info_count;
+        self
+    }
+    #[inline]
+    pub fn vendor_info_count(mut self, vendor_info_count: u32) -> Self {
+        self.inner.vendor_info_count = vendor_info_count;
+        self
+    }
+    #[inline]
+    pub fn vendor_binary_size(mut self, vendor_binary_size: DeviceSize) -> Self {
+        self.inner.vendor_binary_size = vendor_binary_size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DeviceFaultCountsEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultInfoEXT.html>"]
+pub struct DeviceFaultInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub description: [c_char; MAX_DESCRIPTION_SIZE],
+    pub p_address_infos: *mut DeviceFaultAddressInfoEXT,
+    pub p_vendor_infos: *mut DeviceFaultVendorInfoEXT,
+    pub p_vendor_binary_data: *mut c_void,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for DeviceFaultInfoEXT {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("DeviceFaultInfoEXT")
+            .field("s_type", &self.s_type)
+            .field("p_next", &self.p_next)
+            .field("description", &unsafe {
+                ::std::ffi::CStr::from_ptr(self.description.as_ptr())
+            })
+            .field("p_address_infos", &self.p_address_infos)
+            .field("p_vendor_infos", &self.p_vendor_infos)
+            .field("p_vendor_binary_data", &self.p_vendor_binary_data)
+            .finish()
+    }
+}
+impl ::std::default::Default for DeviceFaultInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            description: unsafe { ::std::mem::zeroed() },
+            p_address_infos: ::std::ptr::null_mut(),
+            p_vendor_infos: ::std::ptr::null_mut(),
+            p_vendor_binary_data: ::std::ptr::null_mut(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DeviceFaultInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_INFO_EXT;
+}
+impl DeviceFaultInfoEXT {
+    pub fn builder<'a>() -> DeviceFaultInfoEXTBuilder<'a> {
+        DeviceFaultInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DeviceFaultInfoEXTBuilder<'a> {
+    inner: DeviceFaultInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DeviceFaultInfoEXTBuilder<'a> {
+    type Target = DeviceFaultInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DeviceFaultInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DeviceFaultInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self {
+        self.inner.description = description;
+        self
+    }
+    #[inline]
+    pub fn address_infos(mut self, address_infos: &'a mut DeviceFaultAddressInfoEXT) -> Self {
+        self.inner.p_address_infos = address_infos;
+        self
+    }
+    #[inline]
+    pub fn vendor_infos(mut self, vendor_infos: &'a mut DeviceFaultVendorInfoEXT) -> Self {
+        self.inner.p_vendor_infos = vendor_infos;
+        self
+    }
+    #[inline]
+    pub fn vendor_binary_data(mut self, vendor_binary_data: *mut c_void) -> Self {
+        self.inner.p_vendor_binary_data = vendor_binary_data;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DeviceFaultInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultVendorBinaryHeaderVersionOneEXT.html>"]
+pub struct DeviceFaultVendorBinaryHeaderVersionOneEXT {
+    pub header_size: u32,
+    pub header_version: DeviceFaultVendorBinaryHeaderVersionEXT,
+    pub vendor_id: u32,
+    pub device_id: u32,
+    pub driver_version: u32,
+    pub pipeline_cache_uuid: [u8; UUID_SIZE],
+    pub application_name_offset: u32,
+    pub application_version: u32,
+    pub engine_name_offset: u32,
+    pub engine_version: u32,
+    pub api_version: u32,
+}
+impl ::std::default::Default for DeviceFaultVendorBinaryHeaderVersionOneEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            header_size: u32::default(),
+            header_version: DeviceFaultVendorBinaryHeaderVersionEXT::default(),
+            vendor_id: u32::default(),
+            device_id: u32::default(),
+            driver_version: u32::default(),
+            pipeline_cache_uuid: unsafe { ::std::mem::zeroed() },
+            application_name_offset: u32::default(),
+            application_version: u32::default(),
+            engine_name_offset: u32::default(),
+            engine_version: u32::default(),
+            api_version: u32::default(),
+        }
+    }
+}
+impl DeviceFaultVendorBinaryHeaderVersionOneEXT {
+    pub fn builder<'a>() -> DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
+        DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
+    inner: DeviceFaultVendorBinaryHeaderVersionOneEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
+    type Target = DeviceFaultVendorBinaryHeaderVersionOneEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DeviceFaultVendorBinaryHeaderVersionOneEXTBuilder<'a> {
+    #[inline]
+    pub fn header_size(mut self, header_size: u32) -> Self {
+        self.inner.header_size = header_size;
+        self
+    }
+    #[inline]
+    pub fn header_version(
+        mut self,
+        header_version: DeviceFaultVendorBinaryHeaderVersionEXT,
+    ) -> Self {
+        self.inner.header_version = header_version;
+        self
+    }
+    #[inline]
+    pub fn vendor_id(mut self, vendor_id: u32) -> Self {
+        self.inner.vendor_id = vendor_id;
+        self
+    }
+    #[inline]
+    pub fn device_id(mut self, device_id: u32) -> Self {
+        self.inner.device_id = device_id;
+        self
+    }
+    #[inline]
+    pub fn driver_version(mut self, driver_version: u32) -> Self {
+        self.inner.driver_version = driver_version;
+        self
+    }
+    #[inline]
+    pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self {
+        self.inner.pipeline_cache_uuid = pipeline_cache_uuid;
+        self
+    }
+    #[inline]
+    pub fn application_name_offset(mut self, application_name_offset: u32) -> Self {
+        self.inner.application_name_offset = application_name_offset;
+        self
+    }
+    #[inline]
+    pub fn application_version(mut self, application_version: u32) -> Self {
+        self.inner.application_version = application_version;
+        self
+    }
+    #[inline]
+    pub fn engine_name_offset(mut self, engine_name_offset: u32) -> Self {
+        self.inner.engine_name_offset = engine_name_offset;
+        self
+    }
+    #[inline]
+    pub fn engine_version(mut self, engine_version: u32) -> Self {
+        self.inner.engine_version = engine_version;
+        self
+    }
+    #[inline]
+    pub fn api_version(mut self, api_version: u32) -> Self {
+        self.inner.api_version = api_version;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DeviceFaultVendorBinaryHeaderVersionOneEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.html>"]
+pub struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub pipeline_library_group_handles: Bool32,
+}
+impl ::std::default::Default for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            pipeline_library_group_handles: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT;
+}
+impl PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
+        PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
+    inner: PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn pipeline_library_group_handles(mut self, pipeline_library_group_handles: bool) -> Self {
+        self.inner.pipeline_library_group_handles = pipeline_library_group_handles.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone, Default)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDecompressMemoryRegionNV.html>"]
+pub struct DecompressMemoryRegionNV {
+    pub src_address: DeviceAddress,
+    pub dst_address: DeviceAddress,
+    pub compressed_size: DeviceSize,
+    pub decompressed_size: DeviceSize,
+    pub decompression_method: MemoryDecompressionMethodFlagsNV,
+}
+impl DecompressMemoryRegionNV {
+    pub fn builder<'a>() -> DecompressMemoryRegionNVBuilder<'a> {
+        DecompressMemoryRegionNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DecompressMemoryRegionNVBuilder<'a> {
+    inner: DecompressMemoryRegionNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DecompressMemoryRegionNVBuilder<'a> {
+    type Target = DecompressMemoryRegionNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DecompressMemoryRegionNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DecompressMemoryRegionNVBuilder<'a> {
+    #[inline]
+    pub fn src_address(mut self, src_address: DeviceAddress) -> Self {
+        self.inner.src_address = src_address;
+        self
+    }
+    #[inline]
+    pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self {
+        self.inner.dst_address = dst_address;
+        self
+    }
+    #[inline]
+    pub fn compressed_size(mut self, compressed_size: DeviceSize) -> Self {
+        self.inner.compressed_size = compressed_size;
+        self
+    }
+    #[inline]
+    pub fn decompressed_size(mut self, decompressed_size: DeviceSize) -> Self {
+        self.inner.decompressed_size = decompressed_size;
+        self
+    }
+    #[inline]
+    pub fn decompression_method(
+        mut self,
+        decompression_method: MemoryDecompressionMethodFlagsNV,
+    ) -> Self {
+        self.inner.decompression_method = decompression_method;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DecompressMemoryRegionNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.html>"]
+pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_core_mask: u64,
+    pub shader_core_count: u32,
+    pub shader_warps_per_core: u32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            shader_core_mask: u64::default(),
+            shader_core_count: u32::default(),
+            shader_warps_per_core: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM;
+}
+impl PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
+    pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
+        PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
+    inner: PhysicalDeviceShaderCoreBuiltinsPropertiesARM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreBuiltinsPropertiesARM {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
+    type Target = PhysicalDeviceShaderCoreBuiltinsPropertiesARM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderCoreBuiltinsPropertiesARMBuilder<'a> {
+    #[inline]
+    pub fn shader_core_mask(mut self, shader_core_mask: u64) -> Self {
+        self.inner.shader_core_mask = shader_core_mask;
+        self
+    }
+    #[inline]
+    pub fn shader_core_count(mut self, shader_core_count: u32) -> Self {
+        self.inner.shader_core_count = shader_core_count;
+        self
+    }
+    #[inline]
+    pub fn shader_warps_per_core(mut self, shader_warps_per_core: u32) -> Self {
+        self.inner.shader_warps_per_core = shader_warps_per_core;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.html>"]
+pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_core_builtins: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            shader_core_builtins: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM;
+}
+impl PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
+    pub fn builder<'a>() -> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
+        PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
+    inner: PhysicalDeviceShaderCoreBuiltinsFeaturesARM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARM {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
+    type Target = PhysicalDeviceShaderCoreBuiltinsFeaturesARM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARMBuilder<'a> {
+    #[inline]
+    pub fn shader_core_builtins(mut self, shader_core_builtins: bool) -> Self {
+        self.inner.shader_core_builtins = shader_core_builtins.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.html>"]
+pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub dynamic_rendering_unused_attachments: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            dynamic_rendering_unused_attachments: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT;
+}
+impl PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
+        PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {}
+impl<'a> ::std::ops::Deref
+    for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a>
+{
+    type Target = PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut
+    for PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a>
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn dynamic_rendering_unused_attachments(
+        mut self,
+        dynamic_rendering_unused_attachments: bool,
+    ) -> Self {
+        self.inner.dynamic_rendering_unused_attachments =
+            dynamic_rendering_unused_attachments.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfacePresentModeEXT.html>"]
+pub struct SurfacePresentModeEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub present_mode: PresentModeKHR,
+}
+impl ::std::default::Default for SurfacePresentModeEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            present_mode: PresentModeKHR::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SurfacePresentModeEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_EXT;
+}
+impl SurfacePresentModeEXT {
+    pub fn builder<'a>() -> SurfacePresentModeEXTBuilder<'a> {
+        SurfacePresentModeEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SurfacePresentModeEXTBuilder<'a> {
+    inner: SurfacePresentModeEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceSurfaceInfo2KHR for SurfacePresentModeEXT {}
+impl<'a> ::std::ops::Deref for SurfacePresentModeEXTBuilder<'a> {
+    type Target = SurfacePresentModeEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SurfacePresentModeEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SurfacePresentModeEXTBuilder<'a> {
+    #[inline]
+    pub fn present_mode(mut self, present_mode: PresentModeKHR) -> Self {
+        self.inner.present_mode = present_mode;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SurfacePresentModeEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfacePresentScalingCapabilitiesEXT.html>"]
+pub struct SurfacePresentScalingCapabilitiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub supported_present_scaling: PresentScalingFlagsEXT,
+    pub supported_present_gravity_x: PresentGravityFlagsEXT,
+    pub supported_present_gravity_y: PresentGravityFlagsEXT,
+    pub min_scaled_image_extent: Extent2D,
+    pub max_scaled_image_extent: Extent2D,
+}
+impl ::std::default::Default for SurfacePresentScalingCapabilitiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            supported_present_scaling: PresentScalingFlagsEXT::default(),
+            supported_present_gravity_x: PresentGravityFlagsEXT::default(),
+            supported_present_gravity_y: PresentGravityFlagsEXT::default(),
+            min_scaled_image_extent: Extent2D::default(),
+            max_scaled_image_extent: Extent2D::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SurfacePresentScalingCapabilitiesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_SCALING_CAPABILITIES_EXT;
+}
+impl SurfacePresentScalingCapabilitiesEXT {
+    pub fn builder<'a>() -> SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
+        SurfacePresentScalingCapabilitiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
+    inner: SurfacePresentScalingCapabilitiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesEXTBuilder<'_> {}
+unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentScalingCapabilitiesEXT {}
+impl<'a> ::std::ops::Deref for SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
+    type Target = SurfacePresentScalingCapabilitiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SurfacePresentScalingCapabilitiesEXTBuilder<'a> {
+    #[inline]
+    pub fn supported_present_scaling(
+        mut self,
+        supported_present_scaling: PresentScalingFlagsEXT,
+    ) -> Self {
+        self.inner.supported_present_scaling = supported_present_scaling;
+        self
+    }
+    #[inline]
+    pub fn supported_present_gravity_x(
+        mut self,
+        supported_present_gravity_x: PresentGravityFlagsEXT,
+    ) -> Self {
+        self.inner.supported_present_gravity_x = supported_present_gravity_x;
+        self
+    }
+    #[inline]
+    pub fn supported_present_gravity_y(
+        mut self,
+        supported_present_gravity_y: PresentGravityFlagsEXT,
+    ) -> Self {
+        self.inner.supported_present_gravity_y = supported_present_gravity_y;
+        self
+    }
+    #[inline]
+    pub fn min_scaled_image_extent(mut self, min_scaled_image_extent: Extent2D) -> Self {
+        self.inner.min_scaled_image_extent = min_scaled_image_extent;
+        self
+    }
+    #[inline]
+    pub fn max_scaled_image_extent(mut self, max_scaled_image_extent: Extent2D) -> Self {
+        self.inner.max_scaled_image_extent = max_scaled_image_extent;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SurfacePresentScalingCapabilitiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfacePresentModeCompatibilityEXT.html>"]
+pub struct SurfacePresentModeCompatibilityEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub present_mode_count: u32,
+    pub p_present_modes: *mut PresentModeKHR,
+}
+impl ::std::default::Default for SurfacePresentModeCompatibilityEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            present_mode_count: u32::default(),
+            p_present_modes: ::std::ptr::null_mut(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SurfacePresentModeCompatibilityEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_PRESENT_MODE_COMPATIBILITY_EXT;
+}
+impl SurfacePresentModeCompatibilityEXT {
+    pub fn builder<'a>() -> SurfacePresentModeCompatibilityEXTBuilder<'a> {
+        SurfacePresentModeCompatibilityEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SurfacePresentModeCompatibilityEXTBuilder<'a> {
+    inner: SurfacePresentModeCompatibilityEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityEXTBuilder<'_> {}
+unsafe impl ExtendsSurfaceCapabilities2KHR for SurfacePresentModeCompatibilityEXT {}
+impl<'a> ::std::ops::Deref for SurfacePresentModeCompatibilityEXTBuilder<'a> {
+    type Target = SurfacePresentModeCompatibilityEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SurfacePresentModeCompatibilityEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SurfacePresentModeCompatibilityEXTBuilder<'a> {
+    #[inline]
+    pub fn present_modes(mut self, present_modes: &'a mut [PresentModeKHR]) -> Self {
+        self.inner.present_mode_count = present_modes.len() as _;
+        self.inner.p_present_modes = present_modes.as_mut_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SurfacePresentModeCompatibilityEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.html>"]
+pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub swapchain_maintenance1: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            swapchain_maintenance1: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT;
+}
+impl PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
+        PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceSwapchainMaintenance1FeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSwapchainMaintenance1FeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceSwapchainMaintenance1FeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceSwapchainMaintenance1FeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn swapchain_maintenance1(mut self, swapchain_maintenance1: bool) -> Self {
+        self.inner.swapchain_maintenance1 = swapchain_maintenance1.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentFenceInfoEXT.html>"]
+pub struct SwapchainPresentFenceInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub swapchain_count: u32,
+    pub p_fences: *const Fence,
+}
+impl ::std::default::Default for SwapchainPresentFenceInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            swapchain_count: u32::default(),
+            p_fences: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SwapchainPresentFenceInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_FENCE_INFO_EXT;
+}
+impl SwapchainPresentFenceInfoEXT {
+    pub fn builder<'a>() -> SwapchainPresentFenceInfoEXTBuilder<'a> {
+        SwapchainPresentFenceInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SwapchainPresentFenceInfoEXTBuilder<'a> {
+    inner: SwapchainPresentFenceInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoEXTBuilder<'_> {}
+unsafe impl ExtendsPresentInfoKHR for SwapchainPresentFenceInfoEXT {}
+impl<'a> ::std::ops::Deref for SwapchainPresentFenceInfoEXTBuilder<'a> {
+    type Target = SwapchainPresentFenceInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SwapchainPresentFenceInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SwapchainPresentFenceInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn fences(mut self, fences: &'a [Fence]) -> Self {
+        self.inner.swapchain_count = fences.len() as _;
+        self.inner.p_fences = fences.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SwapchainPresentFenceInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentModesCreateInfoEXT.html>"]
+pub struct SwapchainPresentModesCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub present_mode_count: u32,
+    pub p_present_modes: *const PresentModeKHR,
+}
+impl ::std::default::Default for SwapchainPresentModesCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            present_mode_count: u32::default(),
+            p_present_modes: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SwapchainPresentModesCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT;
+}
+impl SwapchainPresentModesCreateInfoEXT {
+    pub fn builder<'a>() -> SwapchainPresentModesCreateInfoEXTBuilder<'a> {
+        SwapchainPresentModesCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SwapchainPresentModesCreateInfoEXTBuilder<'a> {
+    inner: SwapchainPresentModesCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentModesCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for SwapchainPresentModesCreateInfoEXTBuilder<'a> {
+    type Target = SwapchainPresentModesCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SwapchainPresentModesCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SwapchainPresentModesCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self {
+        self.inner.present_mode_count = present_modes.len() as _;
+        self.inner.p_present_modes = present_modes.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SwapchainPresentModesCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentModeInfoEXT.html>"]
+pub struct SwapchainPresentModeInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub swapchain_count: u32,
+    pub p_present_modes: *const PresentModeKHR,
+}
+impl ::std::default::Default for SwapchainPresentModeInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            swapchain_count: u32::default(),
+            p_present_modes: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SwapchainPresentModeInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_MODE_INFO_EXT;
+}
+impl SwapchainPresentModeInfoEXT {
+    pub fn builder<'a>() -> SwapchainPresentModeInfoEXTBuilder<'a> {
+        SwapchainPresentModeInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SwapchainPresentModeInfoEXTBuilder<'a> {
+    inner: SwapchainPresentModeInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoEXTBuilder<'_> {}
+unsafe impl ExtendsPresentInfoKHR for SwapchainPresentModeInfoEXT {}
+impl<'a> ::std::ops::Deref for SwapchainPresentModeInfoEXTBuilder<'a> {
+    type Target = SwapchainPresentModeInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SwapchainPresentModeInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SwapchainPresentModeInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn present_modes(mut self, present_modes: &'a [PresentModeKHR]) -> Self {
+        self.inner.swapchain_count = present_modes.len() as _;
+        self.inner.p_present_modes = present_modes.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SwapchainPresentModeInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSwapchainPresentScalingCreateInfoEXT.html>"]
+pub struct SwapchainPresentScalingCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub scaling_behavior: PresentScalingFlagsEXT,
+    pub present_gravity_x: PresentGravityFlagsEXT,
+    pub present_gravity_y: PresentGravityFlagsEXT,
+}
+impl ::std::default::Default for SwapchainPresentScalingCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            scaling_behavior: PresentScalingFlagsEXT::default(),
+            present_gravity_x: PresentGravityFlagsEXT::default(),
+            present_gravity_y: PresentGravityFlagsEXT::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for SwapchainPresentScalingCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT;
+}
+impl SwapchainPresentScalingCreateInfoEXT {
+    pub fn builder<'a>() -> SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
+        SwapchainPresentScalingCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
+    inner: SwapchainPresentScalingCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoEXTBuilder<'_> {}
+unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentScalingCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
+    type Target = SwapchainPresentScalingCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> SwapchainPresentScalingCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn scaling_behavior(mut self, scaling_behavior: PresentScalingFlagsEXT) -> Self {
+        self.inner.scaling_behavior = scaling_behavior;
+        self
+    }
+    #[inline]
+    pub fn present_gravity_x(mut self, present_gravity_x: PresentGravityFlagsEXT) -> Self {
+        self.inner.present_gravity_x = present_gravity_x;
+        self
+    }
+    #[inline]
+    pub fn present_gravity_y(mut self, present_gravity_y: PresentGravityFlagsEXT) -> Self {
+        self.inner.present_gravity_y = present_gravity_y;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> SwapchainPresentScalingCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkReleaseSwapchainImagesInfoEXT.html>"]
+pub struct ReleaseSwapchainImagesInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub swapchain: SwapchainKHR,
+    pub image_index_count: u32,
+    pub p_image_indices: *const u32,
+}
+impl ::std::default::Default for ReleaseSwapchainImagesInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            swapchain: SwapchainKHR::default(),
+            image_index_count: u32::default(),
+            p_image_indices: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ReleaseSwapchainImagesInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::RELEASE_SWAPCHAIN_IMAGES_INFO_EXT;
+}
+impl ReleaseSwapchainImagesInfoEXT {
+    pub fn builder<'a>() -> ReleaseSwapchainImagesInfoEXTBuilder<'a> {
+        ReleaseSwapchainImagesInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ReleaseSwapchainImagesInfoEXTBuilder<'a> {
+    inner: ReleaseSwapchainImagesInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for ReleaseSwapchainImagesInfoEXTBuilder<'a> {
+    type Target = ReleaseSwapchainImagesInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ReleaseSwapchainImagesInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ReleaseSwapchainImagesInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn swapchain(mut self, swapchain: SwapchainKHR) -> Self {
+        self.inner.swapchain = swapchain;
+        self
+    }
+    #[inline]
+    pub fn image_indices(mut self, image_indices: &'a [u32]) -> Self {
+        self.inner.image_index_count = image_indices.len() as _;
+        self.inner.p_image_indices = image_indices.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ReleaseSwapchainImagesInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.html>"]
+pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub ray_tracing_invocation_reorder: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            ray_tracing_invocation_reorder: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV;
+}
+impl PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
+    pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
+        PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
+    inner: PhysicalDeviceRayTracingInvocationReorderFeaturesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingInvocationReorderFeaturesNV {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
+    type Target = PhysicalDeviceRayTracingInvocationReorderFeaturesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesNVBuilder<'a> {
+    #[inline]
+    pub fn ray_tracing_invocation_reorder(mut self, ray_tracing_invocation_reorder: bool) -> Self {
+        self.inner.ray_tracing_invocation_reorder = ray_tracing_invocation_reorder.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.html>"]
+pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV,
+}
+impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            ray_tracing_invocation_reorder_reordering_hint:
+                RayTracingInvocationReorderModeNV::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV;
+}
+impl PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
+    pub fn builder<'a>() -> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
+        PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
+    inner: PhysicalDeviceRayTracingInvocationReorderPropertiesNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceRayTracingInvocationReorderPropertiesNV
+{
+}
+impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
+    type Target = PhysicalDeviceRayTracingInvocationReorderPropertiesNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNVBuilder<'a> {
+    #[inline]
+    pub fn ray_tracing_invocation_reorder_reordering_hint(
+        mut self,
+        ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV,
+    ) -> Self {
+        self.inner.ray_tracing_invocation_reorder_reordering_hint =
+            ray_tracing_invocation_reorder_reordering_hint;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingInfoLUNARG.html>"]
+pub struct DirectDriverLoadingInfoLUNARG {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub flags: DirectDriverLoadingFlagsLUNARG,
+    pub pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG,
+}
+#[cfg(feature = "debug")]
+impl fmt::Debug for DirectDriverLoadingInfoLUNARG {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("DirectDriverLoadingInfoLUNARG")
+            .field("s_type", &self.s_type)
+            .field("p_next", &self.p_next)
+            .field("flags", &self.flags)
+            .field(
+                "pfn_get_instance_proc_addr",
+                &(self.pfn_get_instance_proc_addr.map(|x| x as *const ())),
+            )
+            .finish()
+    }
+}
+impl ::std::default::Default for DirectDriverLoadingInfoLUNARG {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            flags: DirectDriverLoadingFlagsLUNARG::default(),
+            pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DirectDriverLoadingInfoLUNARG {
+    const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_INFO_LUNARG;
+}
+impl DirectDriverLoadingInfoLUNARG {
+    pub fn builder<'a>() -> DirectDriverLoadingInfoLUNARGBuilder<'a> {
+        DirectDriverLoadingInfoLUNARGBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DirectDriverLoadingInfoLUNARGBuilder<'a> {
+    inner: DirectDriverLoadingInfoLUNARG,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for DirectDriverLoadingInfoLUNARGBuilder<'a> {
+    type Target = DirectDriverLoadingInfoLUNARG;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DirectDriverLoadingInfoLUNARGBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DirectDriverLoadingInfoLUNARGBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: DirectDriverLoadingFlagsLUNARG) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn pfn_get_instance_proc_addr(
+        mut self,
+        pfn_get_instance_proc_addr: PFN_vkGetInstanceProcAddrLUNARG,
+    ) -> Self {
+        self.inner.pfn_get_instance_proc_addr = pfn_get_instance_proc_addr;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DirectDriverLoadingInfoLUNARG {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingListLUNARG.html>"]
+pub struct DirectDriverLoadingListLUNARG {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub mode: DirectDriverLoadingModeLUNARG,
+    pub driver_count: u32,
+    pub p_drivers: *const DirectDriverLoadingInfoLUNARG,
+}
+impl ::std::default::Default for DirectDriverLoadingListLUNARG {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            mode: DirectDriverLoadingModeLUNARG::default(),
+            driver_count: u32::default(),
+            p_drivers: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for DirectDriverLoadingListLUNARG {
+    const STRUCTURE_TYPE: StructureType = StructureType::DIRECT_DRIVER_LOADING_LIST_LUNARG;
+}
+impl DirectDriverLoadingListLUNARG {
+    pub fn builder<'a>() -> DirectDriverLoadingListLUNARGBuilder<'a> {
+        DirectDriverLoadingListLUNARGBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct DirectDriverLoadingListLUNARGBuilder<'a> {
+    inner: DirectDriverLoadingListLUNARG,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARGBuilder<'_> {}
+unsafe impl ExtendsInstanceCreateInfo for DirectDriverLoadingListLUNARG {}
+impl<'a> ::std::ops::Deref for DirectDriverLoadingListLUNARGBuilder<'a> {
+    type Target = DirectDriverLoadingListLUNARG;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for DirectDriverLoadingListLUNARGBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> DirectDriverLoadingListLUNARGBuilder<'a> {
+    #[inline]
+    pub fn mode(mut self, mode: DirectDriverLoadingModeLUNARG) -> Self {
+        self.inner.mode = mode;
+        self
+    }
+    #[inline]
+    pub fn drivers(mut self, drivers: &'a [DirectDriverLoadingInfoLUNARG]) -> Self {
+        self.inner.driver_count = drivers.len() as _;
+        self.inner.p_drivers = drivers.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> DirectDriverLoadingListLUNARG {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.html>"]
+pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub multiview_per_view_viewports: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            multiview_per_view_viewports: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM;
+}
+impl PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
+    pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
+        PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
+    inner: PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
+    type Target = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOMBuilder<'a> {
+    #[inline]
+    pub fn multiview_per_view_viewports(mut self, multiview_per_view_viewports: bool) -> Self {
+        self.inner.multiview_per_view_viewports = multiview_per_view_viewports.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.html>"]
+pub struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub ray_tracing_position_fetch: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            ray_tracing_position_fetch: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR;
+}
+impl PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
+    pub fn builder<'a>() -> PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
+        PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
+    inner: PhysicalDeviceRayTracingPositionFetchFeaturesKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingPositionFetchFeaturesKHR {}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingPositionFetchFeaturesKHR {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
+    type Target = PhysicalDeviceRayTracingPositionFetchFeaturesKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceRayTracingPositionFetchFeaturesKHRBuilder<'a> {
+    #[inline]
+    pub fn ray_tracing_position_fetch(mut self, ray_tracing_position_fetch: bool) -> Self {
+        self.inner.ray_tracing_position_fetch = ray_tracing_position_fetch.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderCorePropertiesARM.html>"]
+pub struct PhysicalDeviceShaderCorePropertiesARM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub pixel_rate: u32,
+    pub texel_rate: u32,
+    pub fma_rate: u32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderCorePropertiesARM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            pixel_rate: u32::default(),
+            texel_rate: u32::default(),
+            fma_rate: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderCorePropertiesARM {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM;
+}
+impl PhysicalDeviceShaderCorePropertiesARM {
+    pub fn builder<'a>() -> PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
+        PhysicalDeviceShaderCorePropertiesARMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
+    inner: PhysicalDeviceShaderCorePropertiesARM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesARMBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCorePropertiesARM {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
+    type Target = PhysicalDeviceShaderCorePropertiesARM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderCorePropertiesARMBuilder<'a> {
+    #[inline]
+    pub fn pixel_rate(mut self, pixel_rate: u32) -> Self {
+        self.inner.pixel_rate = pixel_rate;
+        self
+    }
+    #[inline]
+    pub fn texel_rate(mut self, texel_rate: u32) -> Self {
+        self.inner.texel_rate = texel_rate;
+        self
+    }
+    #[inline]
+    pub fn fma_rate(mut self, fma_rate: u32) -> Self {
+        self.inner.fma_rate = fma_rate;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderCorePropertiesARM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.html>"]
+pub struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub multiview_per_view_render_areas: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            multiview_per_view_render_areas: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM;
+}
+impl PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
+    pub fn builder<'a>() -> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
+        PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
+    inner: PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2
+    for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM
+{
+}
+unsafe impl ExtendsDeviceCreateInfo
+    for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
+    type Target = PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOMBuilder<'a> {
+    #[inline]
+    pub fn multiview_per_view_render_areas(
+        mut self,
+        multiview_per_view_render_areas: bool,
+    ) -> Self {
+        self.inner.multiview_per_view_render_areas = multiview_per_view_render_areas.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.html>"]
+pub struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub per_view_render_area_count: u32,
+    pub p_per_view_render_areas: *const Rect2D,
+}
+impl ::std::default::Default for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            per_view_render_area_count: u32::default(),
+            p_per_view_render_areas: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM;
+}
+impl MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
+    pub fn builder<'a>() -> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
+        MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
+    inner: MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsRenderPassBeginInfo
+    for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'_>
+{
+}
+unsafe impl ExtendsRenderPassBeginInfo for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {}
+unsafe impl ExtendsRenderingInfo for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'_> {}
+unsafe impl ExtendsRenderingInfo for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {}
+impl<'a> ::std::ops::Deref for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
+    type Target = MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOMBuilder<'a> {
+    #[inline]
+    pub fn per_view_render_areas(mut self, per_view_render_areas: &'a [Rect2D]) -> Self {
+        self.inner.per_view_render_area_count = per_view_render_areas.len() as _;
+        self.inner.p_per_view_render_areas = per_view_render_areas.as_ptr();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryLowLatencySupportNV.html>"]
+pub struct QueryLowLatencySupportNV {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub p_queried_low_latency_data: *mut c_void,
+}
+impl ::std::default::Default for QueryLowLatencySupportNV {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            p_queried_low_latency_data: ::std::ptr::null_mut(),
+        }
+    }
+}
+unsafe impl TaggedStructure for QueryLowLatencySupportNV {
+    const STRUCTURE_TYPE: StructureType = StructureType::QUERY_LOW_LATENCY_SUPPORT_NV;
+}
+impl QueryLowLatencySupportNV {
+    pub fn builder<'a>() -> QueryLowLatencySupportNVBuilder<'a> {
+        QueryLowLatencySupportNVBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct QueryLowLatencySupportNVBuilder<'a> {
+    inner: QueryLowLatencySupportNV,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsSemaphoreCreateInfo for QueryLowLatencySupportNVBuilder<'_> {}
+unsafe impl ExtendsSemaphoreCreateInfo for QueryLowLatencySupportNV {}
+impl<'a> ::std::ops::Deref for QueryLowLatencySupportNVBuilder<'a> {
+    type Target = QueryLowLatencySupportNV;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for QueryLowLatencySupportNVBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> QueryLowLatencySupportNVBuilder<'a> {
+    #[inline]
+    pub fn queried_low_latency_data(mut self, queried_low_latency_data: *mut c_void) -> Self {
+        self.inner.p_queried_low_latency_data = queried_low_latency_data;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> QueryLowLatencySupportNV {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryMapInfoKHR.html>"]
+pub struct MemoryMapInfoKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub flags: MemoryMapFlags,
+    pub memory: DeviceMemory,
+    pub offset: DeviceSize,
+    pub size: DeviceSize,
+}
+impl ::std::default::Default for MemoryMapInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            flags: MemoryMapFlags::default(),
+            memory: DeviceMemory::default(),
+            offset: DeviceSize::default(),
+            size: DeviceSize::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for MemoryMapInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_MAP_INFO_KHR;
+}
+impl MemoryMapInfoKHR {
+    pub fn builder<'a>() -> MemoryMapInfoKHRBuilder<'a> {
+        MemoryMapInfoKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MemoryMapInfoKHRBuilder<'a> {
+    inner: MemoryMapInfoKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for MemoryMapInfoKHRBuilder<'a> {
+    type Target = MemoryMapInfoKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MemoryMapInfoKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MemoryMapInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: MemoryMapFlags) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn memory(mut self, memory: DeviceMemory) -> Self {
+        self.inner.memory = memory;
+        self
+    }
+    #[inline]
+    pub fn offset(mut self, offset: DeviceSize) -> Self {
+        self.inner.offset = offset;
+        self
+    }
+    #[inline]
+    pub fn size(mut self, size: DeviceSize) -> Self {
+        self.inner.size = size;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MemoryMapInfoKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryUnmapInfoKHR.html>"]
+pub struct MemoryUnmapInfoKHR {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub flags: MemoryUnmapFlagsKHR,
+    pub memory: DeviceMemory,
+}
+impl ::std::default::Default for MemoryUnmapInfoKHR {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            flags: MemoryUnmapFlagsKHR::default(),
+            memory: DeviceMemory::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for MemoryUnmapInfoKHR {
+    const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_UNMAP_INFO_KHR;
+}
+impl MemoryUnmapInfoKHR {
+    pub fn builder<'a>() -> MemoryUnmapInfoKHRBuilder<'a> {
+        MemoryUnmapInfoKHRBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct MemoryUnmapInfoKHRBuilder<'a> {
+    inner: MemoryUnmapInfoKHR,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+impl<'a> ::std::ops::Deref for MemoryUnmapInfoKHRBuilder<'a> {
+    type Target = MemoryUnmapInfoKHR;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for MemoryUnmapInfoKHRBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> MemoryUnmapInfoKHRBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: MemoryUnmapFlagsKHR) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn memory(mut self, memory: DeviceMemory) -> Self {
+        self.inner.memory = memory;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> MemoryUnmapInfoKHR {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderObjectFeaturesEXT.html>"]
+pub struct PhysicalDeviceShaderObjectFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_object: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderObjectFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            shader_object: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderObjectFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT;
+}
+impl PhysicalDeviceShaderObjectFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
+        PhysicalDeviceShaderObjectFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceShaderObjectFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderObjectFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderObjectFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceShaderObjectFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderObjectFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn shader_object(mut self, shader_object: bool) -> Self {
+        self.inner.shader_object = shader_object.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderObjectFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderObjectPropertiesEXT.html>"]
+pub struct PhysicalDeviceShaderObjectPropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_binary_uuid: [u8; UUID_SIZE],
+    pub shader_binary_version: u32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderObjectPropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            shader_binary_uuid: unsafe { ::std::mem::zeroed() },
+            shader_binary_version: u32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderObjectPropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT;
+}
+impl PhysicalDeviceShaderObjectPropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
+        PhysicalDeviceShaderObjectPropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
+    inner: PhysicalDeviceShaderObjectPropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderObjectPropertiesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
+    type Target = PhysicalDeviceShaderObjectPropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderObjectPropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn shader_binary_uuid(mut self, shader_binary_uuid: [u8; UUID_SIZE]) -> Self {
+        self.inner.shader_binary_uuid = shader_binary_uuid;
+        self
+    }
+    #[inline]
+    pub fn shader_binary_version(mut self, shader_binary_version: u32) -> Self {
+        self.inner.shader_binary_version = shader_binary_version;
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderObjectPropertiesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCreateInfoEXT.html>"]
+pub struct ShaderCreateInfoEXT {
+    pub s_type: StructureType,
+    pub p_next: *const c_void,
+    pub flags: ShaderCreateFlagsEXT,
+    pub stage: ShaderStageFlags,
+    pub next_stage: ShaderStageFlags,
+    pub code_type: ShaderCodeTypeEXT,
+    pub code_size: usize,
+    pub p_code: *const c_void,
+    pub p_name: *const c_char,
+    pub set_layout_count: u32,
+    pub p_set_layouts: *const DescriptorSetLayout,
+    pub push_constant_range_count: u32,
+    pub p_push_constant_ranges: *const PushConstantRange,
+    pub p_specialization_info: *const SpecializationInfo,
+}
+impl ::std::default::Default for ShaderCreateInfoEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null(),
+            flags: ShaderCreateFlagsEXT::default(),
+            stage: ShaderStageFlags::default(),
+            next_stage: ShaderStageFlags::default(),
+            code_type: ShaderCodeTypeEXT::default(),
+            code_size: usize::default(),
+            p_code: ::std::ptr::null(),
+            p_name: ::std::ptr::null(),
+            set_layout_count: u32::default(),
+            p_set_layouts: ::std::ptr::null(),
+            push_constant_range_count: u32::default(),
+            p_push_constant_ranges: ::std::ptr::null(),
+            p_specialization_info: ::std::ptr::null(),
+        }
+    }
+}
+unsafe impl TaggedStructure for ShaderCreateInfoEXT {
+    const STRUCTURE_TYPE: StructureType = StructureType::SHADER_CREATE_INFO_EXT;
+}
+impl ShaderCreateInfoEXT {
+    pub fn builder<'a>() -> ShaderCreateInfoEXTBuilder<'a> {
+        ShaderCreateInfoEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct ShaderCreateInfoEXTBuilder<'a> {
+    inner: ShaderCreateInfoEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+pub unsafe trait ExtendsShaderCreateInfoEXT {}
+impl<'a> ::std::ops::Deref for ShaderCreateInfoEXTBuilder<'a> {
+    type Target = ShaderCreateInfoEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for ShaderCreateInfoEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> ShaderCreateInfoEXTBuilder<'a> {
+    #[inline]
+    pub fn flags(mut self, flags: ShaderCreateFlagsEXT) -> Self {
+        self.inner.flags = flags;
+        self
+    }
+    #[inline]
+    pub fn stage(mut self, stage: ShaderStageFlags) -> Self {
+        self.inner.stage = stage;
+        self
+    }
+    #[inline]
+    pub fn next_stage(mut self, next_stage: ShaderStageFlags) -> Self {
+        self.inner.next_stage = next_stage;
+        self
+    }
+    #[inline]
+    pub fn code_type(mut self, code_type: ShaderCodeTypeEXT) -> Self {
+        self.inner.code_type = code_type;
+        self
+    }
+    #[inline]
+    pub fn code(mut self, code: &'a [u8]) -> Self {
+        self.inner.code_size = code.len();
+        self.inner.p_code = code.as_ptr().cast();
+        self
+    }
+    #[inline]
+    pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self {
+        self.inner.p_name = name.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn set_layouts(mut self, set_layouts: &'a [DescriptorSetLayout]) -> Self {
+        self.inner.set_layout_count = set_layouts.len() as _;
+        self.inner.p_set_layouts = set_layouts.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn push_constant_ranges(mut self, push_constant_ranges: &'a [PushConstantRange]) -> Self {
+        self.inner.push_constant_range_count = push_constant_ranges.len() as _;
+        self.inner.p_push_constant_ranges = push_constant_ranges.as_ptr();
+        self
+    }
+    #[inline]
+    pub fn specialization_info(mut self, specialization_info: &'a SpecializationInfo) -> Self {
+        self.inner.p_specialization_info = specialization_info;
+        self
+    }
+    #[doc = r" Prepends the given extension struct between the root and the first pointer. This"]
+    #[doc = r" method only exists on structs that can be passed to a function directly. Only"]
+    #[doc = r" valid extension structs can be pushed into the chain."]
+    #[doc = r" If the chain looks like `A -> B -> C`, and you call `builder.push_next(&mut D)`, then the"]
+    #[doc = r" chain will look like `A -> D -> B -> C`."]
+    pub fn push_next<T: ExtendsShaderCreateInfoEXT>(mut self, next: &'a mut T) -> Self {
+        unsafe {
+            let next_ptr = <*const T>::cast(next);
+            let last_next = ptr_chain_iter(next).last().unwrap();
+            (*last_next).p_next = self.inner.p_next as _;
+            self.inner.p_next = next_ptr;
+        }
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> ShaderCreateInfoEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTileImageFeaturesEXT.html>"]
+pub struct PhysicalDeviceShaderTileImageFeaturesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_tile_image_color_read_access: Bool32,
+    pub shader_tile_image_depth_read_access: Bool32,
+    pub shader_tile_image_stencil_read_access: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderTileImageFeaturesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            shader_tile_image_color_read_access: Bool32::default(),
+            shader_tile_image_depth_read_access: Bool32::default(),
+            shader_tile_image_stencil_read_access: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderTileImageFeaturesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT;
+}
+impl PhysicalDeviceShaderTileImageFeaturesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
+        PhysicalDeviceShaderTileImageFeaturesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
+    inner: PhysicalDeviceShaderTileImageFeaturesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderTileImageFeaturesEXT {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'_> {}
+unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderTileImageFeaturesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
+    type Target = PhysicalDeviceShaderTileImageFeaturesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderTileImageFeaturesEXTBuilder<'a> {
+    #[inline]
+    pub fn shader_tile_image_color_read_access(
+        mut self,
+        shader_tile_image_color_read_access: bool,
+    ) -> Self {
+        self.inner.shader_tile_image_color_read_access = shader_tile_image_color_read_access.into();
+        self
+    }
+    #[inline]
+    pub fn shader_tile_image_depth_read_access(
+        mut self,
+        shader_tile_image_depth_read_access: bool,
+    ) -> Self {
+        self.inner.shader_tile_image_depth_read_access = shader_tile_image_depth_read_access.into();
+        self
+    }
+    #[inline]
+    pub fn shader_tile_image_stencil_read_access(
+        mut self,
+        shader_tile_image_stencil_read_access: bool,
+    ) -> Self {
+        self.inner.shader_tile_image_stencil_read_access =
+            shader_tile_image_stencil_read_access.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderTileImageFeaturesEXT {
+        self.inner
+    }
+}
+#[repr(C)]
+#[cfg_attr(feature = "debug", derive(Debug))]
+#[derive(Copy, Clone)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceShaderTileImagePropertiesEXT.html>"]
+pub struct PhysicalDeviceShaderTileImagePropertiesEXT {
+    pub s_type: StructureType,
+    pub p_next: *mut c_void,
+    pub shader_tile_image_coherent_read_accelerated: Bool32,
+    pub shader_tile_image_read_sample_from_pixel_rate_invocation: Bool32,
+    pub shader_tile_image_read_from_helper_invocation: Bool32,
+}
+impl ::std::default::Default for PhysicalDeviceShaderTileImagePropertiesEXT {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            s_type: Self::STRUCTURE_TYPE,
+            p_next: ::std::ptr::null_mut(),
+            shader_tile_image_coherent_read_accelerated: Bool32::default(),
+            shader_tile_image_read_sample_from_pixel_rate_invocation: Bool32::default(),
+            shader_tile_image_read_from_helper_invocation: Bool32::default(),
+        }
+    }
+}
+unsafe impl TaggedStructure for PhysicalDeviceShaderTileImagePropertiesEXT {
+    const STRUCTURE_TYPE: StructureType =
+        StructureType::PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT;
+}
+impl PhysicalDeviceShaderTileImagePropertiesEXT {
+    pub fn builder<'a>() -> PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
+        PhysicalDeviceShaderTileImagePropertiesEXTBuilder {
+            inner: Self::default(),
+            marker: ::std::marker::PhantomData,
+        }
+    }
+}
+#[repr(transparent)]
+pub struct PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
+    inner: PhysicalDeviceShaderTileImagePropertiesEXT,
+    marker: ::std::marker::PhantomData<&'a ()>,
+}
+unsafe impl ExtendsPhysicalDeviceProperties2
+    for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'_>
+{
+}
+unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderTileImagePropertiesEXT {}
+impl<'a> ::std::ops::Deref for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
+    type Target = PhysicalDeviceShaderTileImagePropertiesEXT;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+impl<'a> ::std::ops::DerefMut for PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+impl<'a> PhysicalDeviceShaderTileImagePropertiesEXTBuilder<'a> {
+    #[inline]
+    pub fn shader_tile_image_coherent_read_accelerated(
+        mut self,
+        shader_tile_image_coherent_read_accelerated: bool,
+    ) -> Self {
+        self.inner.shader_tile_image_coherent_read_accelerated =
+            shader_tile_image_coherent_read_accelerated.into();
+        self
+    }
+    #[inline]
+    pub fn shader_tile_image_read_sample_from_pixel_rate_invocation(
+        mut self,
+        shader_tile_image_read_sample_from_pixel_rate_invocation: bool,
+    ) -> Self {
+        self.inner
+            .shader_tile_image_read_sample_from_pixel_rate_invocation =
+            shader_tile_image_read_sample_from_pixel_rate_invocation.into();
+        self
+    }
+    #[inline]
+    pub fn shader_tile_image_read_from_helper_invocation(
+        mut self,
+        shader_tile_image_read_from_helper_invocation: bool,
+    ) -> Self {
+        self.inner.shader_tile_image_read_from_helper_invocation =
+            shader_tile_image_read_from_helper_invocation.into();
+        self
+    }
+    #[doc = r" Calling build will **discard** all the lifetime information. Only call this if"]
+    #[doc = r" necessary! Builders implement `Deref` targeting their corresponding Vulkan struct,"]
+    #[doc = r" so references to builders can be passed directly to Vulkan functions."]
+    pub fn build(self) -> PhysicalDeviceShaderTileImagePropertiesEXT {
+        self.inner
+    }
+}
diff --git a/src/vk/enums.rs b/src/vk/enums.rs
index 46160df..6201209 100644
--- a/src/vk/enums.rs
+++ b/src/vk/enums.rs
@@ -1,12 +1,14 @@
 use std::fmt;
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageLayout.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageLayout.html>"]
 pub struct ImageLayout(pub(crate) i32);
 impl ImageLayout {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ImageLayout(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -33,12 +35,14 @@ impl ImageLayout {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentLoadOp.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentLoadOp.html>"]
 pub struct AttachmentLoadOp(pub(crate) i32);
 impl AttachmentLoadOp {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        AttachmentLoadOp(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -50,12 +54,14 @@ impl AttachmentLoadOp {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAttachmentStoreOp.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAttachmentStoreOp.html>"]
 pub struct AttachmentStoreOp(pub(crate) i32);
 impl AttachmentStoreOp {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        AttachmentStoreOp(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -66,12 +72,14 @@ impl AttachmentStoreOp {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageType.html>"]
 pub struct ImageType(pub(crate) i32);
 impl ImageType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ImageType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -83,12 +91,14 @@ impl ImageType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageTiling.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageTiling.html>"]
 pub struct ImageTiling(pub(crate) i32);
 impl ImageTiling {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ImageTiling(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -99,12 +109,14 @@ impl ImageTiling {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkImageViewType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkImageViewType.html>"]
 pub struct ImageViewType(pub(crate) i32);
 impl ImageViewType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ImageViewType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -120,12 +132,14 @@ impl ImageViewType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCommandBufferLevel.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCommandBufferLevel.html>"]
 pub struct CommandBufferLevel(pub(crate) i32);
 impl CommandBufferLevel {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        CommandBufferLevel(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -136,12 +150,14 @@ impl CommandBufferLevel {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkComponentSwizzle.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComponentSwizzle.html>"]
 pub struct ComponentSwizzle(pub(crate) i32);
 impl ComponentSwizzle {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ComponentSwizzle(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -157,12 +173,14 @@ impl ComponentSwizzle {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorType.html>"]
 pub struct DescriptorType(pub(crate) i32);
 impl DescriptorType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DescriptorType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -182,12 +200,14 @@ impl DescriptorType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryType.html>"]
 pub struct QueryType(pub(crate) i32);
 impl QueryType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        QueryType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -200,12 +220,14 @@ impl QueryType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBorderColor.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBorderColor.html>"]
 pub struct BorderColor(pub(crate) i32);
 impl BorderColor {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        BorderColor(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -220,12 +242,14 @@ impl BorderColor {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineBindPoint.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineBindPoint.html>"]
 pub struct PipelineBindPoint(pub(crate) i32);
 impl PipelineBindPoint {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PipelineBindPoint(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -236,12 +260,14 @@ impl PipelineBindPoint {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineCacheHeaderVersion.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineCacheHeaderVersion.html>"]
 pub struct PipelineCacheHeaderVersion(pub(crate) i32);
 impl PipelineCacheHeaderVersion {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PipelineCacheHeaderVersion(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -251,12 +277,14 @@ impl PipelineCacheHeaderVersion {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPrimitiveTopology.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPrimitiveTopology.html>"]
 pub struct PrimitiveTopology(pub(crate) i32);
 impl PrimitiveTopology {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PrimitiveTopology(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -276,12 +304,14 @@ impl PrimitiveTopology {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSharingMode.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSharingMode.html>"]
 pub struct SharingMode(pub(crate) i32);
 impl SharingMode {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        SharingMode(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -292,12 +322,14 @@ impl SharingMode {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndexType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndexType.html>"]
 pub struct IndexType(pub(crate) i32);
 impl IndexType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        IndexType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -308,12 +340,14 @@ impl IndexType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFilter.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFilter.html>"]
 pub struct Filter(pub(crate) i32);
 impl Filter {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        Filter(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -324,12 +358,14 @@ impl Filter {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerMipmapMode.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerMipmapMode.html>"]
 pub struct SamplerMipmapMode(pub(crate) i32);
 impl SamplerMipmapMode {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        SamplerMipmapMode(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -342,12 +378,14 @@ impl SamplerMipmapMode {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerAddressMode.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerAddressMode.html>"]
 pub struct SamplerAddressMode(pub(crate) i32);
 impl SamplerAddressMode {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        SamplerAddressMode(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -360,12 +398,14 @@ impl SamplerAddressMode {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCompareOp.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCompareOp.html>"]
 pub struct CompareOp(pub(crate) i32);
 impl CompareOp {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        CompareOp(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -382,12 +422,14 @@ impl CompareOp {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPolygonMode.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPolygonMode.html>"]
 pub struct PolygonMode(pub(crate) i32);
 impl PolygonMode {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PolygonMode(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -399,12 +441,14 @@ impl PolygonMode {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFrontFace.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFrontFace.html>"]
 pub struct FrontFace(pub(crate) i32);
 impl FrontFace {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        FrontFace(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -415,12 +459,14 @@ impl FrontFace {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBlendFactor.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlendFactor.html>"]
 pub struct BlendFactor(pub(crate) i32);
 impl BlendFactor {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        BlendFactor(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -448,12 +494,14 @@ impl BlendFactor {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBlendOp.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlendOp.html>"]
 pub struct BlendOp(pub(crate) i32);
 impl BlendOp {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        BlendOp(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -467,12 +515,14 @@ impl BlendOp {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStencilOp.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStencilOp.html>"]
 pub struct StencilOp(pub(crate) i32);
 impl StencilOp {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        StencilOp(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -489,12 +539,14 @@ impl StencilOp {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkLogicOp.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLogicOp.html>"]
 pub struct LogicOp(pub(crate) i32);
 impl LogicOp {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        LogicOp(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -519,12 +571,14 @@ impl LogicOp {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkInternalAllocationType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkInternalAllocationType.html>"]
 pub struct InternalAllocationType(pub(crate) i32);
 impl InternalAllocationType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        InternalAllocationType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -534,12 +588,14 @@ impl InternalAllocationType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSystemAllocationScope.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSystemAllocationScope.html>"]
 pub struct SystemAllocationScope(pub(crate) i32);
 impl SystemAllocationScope {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        SystemAllocationScope(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -553,12 +609,14 @@ impl SystemAllocationScope {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPhysicalDeviceType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceType.html>"]
 pub struct PhysicalDeviceType(pub(crate) i32);
 impl PhysicalDeviceType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PhysicalDeviceType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -572,12 +630,14 @@ impl PhysicalDeviceType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputRate.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVertexInputRate.html>"]
 pub struct VertexInputRate(pub(crate) i32);
 impl VertexInputRate {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        VertexInputRate(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -588,12 +648,14 @@ impl VertexInputRate {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFormat.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFormat.html>"]
 pub struct Format(pub(crate) i32);
 impl Format {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        Format(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -787,12 +849,14 @@ impl Format {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkStructureType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkStructureType.html>"]
 pub struct StructureType(pub(crate) i32);
 impl StructureType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        StructureType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -852,12 +916,14 @@ impl StructureType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSubpassContents.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassContents.html>"]
 pub struct SubpassContents(pub(crate) i32);
 impl SubpassContents {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        SubpassContents(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -868,13 +934,15 @@ impl SubpassContents {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkResult.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkResult.html>"]
 #[must_use]
 pub struct Result(pub(crate) i32);
 impl Result {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        Result(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -896,9 +964,9 @@ impl Result {
     pub const ERROR_OUT_OF_HOST_MEMORY: Self = Self(-1);
     #[doc = "A device memory allocation has failed"]
     pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Self(-2);
-    #[doc = "Initialization of a object has failed"]
+    #[doc = "Initialization of an object has failed"]
     pub const ERROR_INITIALIZATION_FAILED: Self = Self(-3);
-    #[doc = "The logical device has been lost. See <<devsandqueues-lost-device>>"]
+    #[doc = "The logical device has been lost. See <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#devsandqueues-lost-device>"]
     pub const ERROR_DEVICE_LOST: Self = Self(-4);
     #[doc = "Mapping of a memory object has failed"]
     pub const ERROR_MEMORY_MAP_FAILED: Self = Self(-5);
@@ -922,40 +990,7 @@ impl Result {
 impl ::std::error::Error for Result {}
 impl fmt::Display for Result {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        let name = match *self {
-            Result::SUCCESS => Some("Command completed successfully"),
-            Result::NOT_READY => Some("A fence or query has not yet completed"),
-            Result::TIMEOUT => Some("A wait operation has not completed in the specified time"),
-            Result::EVENT_SET => Some("An event is signaled"),
-            Result::EVENT_RESET => Some("An event is unsignaled"),
-            Result::INCOMPLETE => Some("A return array was too small for the result"),
-            Result::ERROR_OUT_OF_HOST_MEMORY => Some("A host memory allocation has failed"),
-            Result::ERROR_OUT_OF_DEVICE_MEMORY => Some("A device memory allocation has failed"),
-            Result::ERROR_INITIALIZATION_FAILED => Some("Initialization of a object has failed"),
-            Result::ERROR_DEVICE_LOST => {
-                Some("The logical device has been lost. See <<devsandqueues-lost-device>>")
-            }
-            Result::ERROR_MEMORY_MAP_FAILED => Some("Mapping of a memory object has failed"),
-            Result::ERROR_LAYER_NOT_PRESENT => Some("Layer specified does not exist"),
-            Result::ERROR_EXTENSION_NOT_PRESENT => Some("Extension specified does not exist"),
-            Result::ERROR_FEATURE_NOT_PRESENT => {
-                Some("Requested feature is not available on this device")
-            }
-            Result::ERROR_INCOMPATIBLE_DRIVER => Some("Unable to find a Vulkan driver"),
-            Result::ERROR_TOO_MANY_OBJECTS => {
-                Some("Too many objects of the type have already been created")
-            }
-            Result::ERROR_FORMAT_NOT_SUPPORTED => {
-                Some("Requested format is not supported on this device")
-            }
-            Result::ERROR_FRAGMENTED_POOL => Some(
-                "A requested pool allocation has failed due to fragmentation of the pool's memory",
-            ),
-            Result::ERROR_UNKNOWN => {
-                Some("An unknown error has occurred, due to an implementation or application bug")
-            }
-            _ => None,
-        };
+        let name = match * self { Self :: SUCCESS => Some ("Command completed successfully") , Self :: NOT_READY => Some ("A fence or query has not yet completed") , Self :: TIMEOUT => Some ("A wait operation has not completed in the specified time") , Self :: EVENT_SET => Some ("An event is signaled") , Self :: EVENT_RESET => Some ("An event is unsignaled") , Self :: INCOMPLETE => Some ("A return array was too small for the result") , Self :: ERROR_OUT_OF_HOST_MEMORY => Some ("A host memory allocation has failed") , Self :: ERROR_OUT_OF_DEVICE_MEMORY => Some ("A device memory allocation has failed") , Self :: ERROR_INITIALIZATION_FAILED => Some ("Initialization of an object has failed") , Self :: ERROR_DEVICE_LOST => Some ("The logical device has been lost. See <https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#devsandqueues-lost-device>") , Self :: ERROR_MEMORY_MAP_FAILED => Some ("Mapping of a memory object has failed") , Self :: ERROR_LAYER_NOT_PRESENT => Some ("Layer specified does not exist") , Self :: ERROR_EXTENSION_NOT_PRESENT => Some ("Extension specified does not exist") , Self :: ERROR_FEATURE_NOT_PRESENT => Some ("Requested feature is not available on this device") , Self :: ERROR_INCOMPATIBLE_DRIVER => Some ("Unable to find a Vulkan driver") , Self :: ERROR_TOO_MANY_OBJECTS => Some ("Too many objects of the type have already been created") , Self :: ERROR_FORMAT_NOT_SUPPORTED => Some ("Requested format is not supported on this device") , Self :: ERROR_FRAGMENTED_POOL => Some ("A requested pool allocation has failed due to fragmentation of the pool's memory") , Self :: ERROR_UNKNOWN => Some ("An unknown error has occurred, due to an implementation or application bug") , _ => None , } ;
         if let Some(x) = name {
             fmt.write_str(x)
         } else {
@@ -965,12 +1000,14 @@ impl fmt::Display for Result {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDynamicState.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDynamicState.html>"]
 pub struct DynamicState(pub(crate) i32);
 impl DynamicState {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DynamicState(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -988,12 +1025,14 @@ impl DynamicState {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDescriptorUpdateTemplateType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDescriptorUpdateTemplateType.html>"]
 pub struct DescriptorUpdateTemplateType(pub(crate) i32);
 impl DescriptorUpdateTemplateType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DescriptorUpdateTemplateType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1004,12 +1043,14 @@ impl DescriptorUpdateTemplateType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkObjectType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkObjectType.html>"]
 pub struct ObjectType(pub(crate) i32);
 impl ObjectType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ObjectType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1044,12 +1085,50 @@ impl ObjectType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSemaphoreType.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingInvocationReorderModeNV.html>"]
+pub struct RayTracingInvocationReorderModeNV(pub(crate) i32);
+impl RayTracingInvocationReorderModeNV {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl RayTracingInvocationReorderModeNV {
+    pub const NONE: Self = Self(0);
+    pub const REORDER: Self = Self(1);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDirectDriverLoadingModeLUNARG.html>"]
+pub struct DirectDriverLoadingModeLUNARG(pub(crate) i32);
+impl DirectDriverLoadingModeLUNARG {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl DirectDriverLoadingModeLUNARG {
+    pub const EXCLUSIVE: Self = Self(0);
+    pub const INCLUSIVE: Self = Self(1);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSemaphoreType.html>"]
 pub struct SemaphoreType(pub(crate) i32);
 impl SemaphoreType {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        SemaphoreType(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1060,12 +1139,14 @@ impl SemaphoreType {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPresentModeKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentModeKHR.html>"]
 pub struct PresentModeKHR(pub(crate) i32);
 impl PresentModeKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PresentModeKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1078,29 +1159,31 @@ impl PresentModeKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkColorSpaceKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkColorSpaceKHR.html>"]
 pub struct ColorSpaceKHR(pub(crate) i32);
 impl ColorSpaceKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ColorSpaceKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
 }
 impl ColorSpaceKHR {
     pub const SRGB_NONLINEAR: Self = Self(0);
-    #[deprecated = "Backwards-compatible alias containing a typo"]
-    pub const COLORSPACE_SRGB_NONLINEAR: Self = Self::SRGB_NONLINEAR;
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTimeDomainEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTimeDomainEXT.html>"]
 pub struct TimeDomainEXT(pub(crate) i32);
 impl TimeDomainEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        TimeDomainEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1113,12 +1196,14 @@ impl TimeDomainEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDebugReportObjectTypeEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDebugReportObjectTypeEXT.html>"]
 pub struct DebugReportObjectTypeEXT(pub(crate) i32);
 impl DebugReportObjectTypeEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DebugReportObjectTypeEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1153,22 +1238,20 @@ impl DebugReportObjectTypeEXT {
     pub const SURFACE_KHR: Self = Self(26);
     pub const SWAPCHAIN_KHR: Self = Self(27);
     pub const DEBUG_REPORT_CALLBACK_EXT: Self = Self(28);
-    #[deprecated = "Backwards-compatible alias containing a typo"]
-    pub const DEBUG_REPORT: Self = Self::DEBUG_REPORT_CALLBACK_EXT;
     pub const DISPLAY_KHR: Self = Self(29);
     pub const DISPLAY_MODE_KHR: Self = Self(30);
     pub const VALIDATION_CACHE_EXT: Self = Self(33);
-    #[deprecated = "Backwards-compatible alias containing a typo"]
-    pub const VALIDATION_CACHE: Self = Self::VALIDATION_CACHE_EXT;
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceMemoryReportEventTypeEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceMemoryReportEventTypeEXT.html>"]
 pub struct DeviceMemoryReportEventTypeEXT(pub(crate) i32);
 impl DeviceMemoryReportEventTypeEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DeviceMemoryReportEventTypeEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1182,12 +1265,14 @@ impl DeviceMemoryReportEventTypeEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRasterizationOrderAMD.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRasterizationOrderAMD.html>"]
 pub struct RasterizationOrderAMD(pub(crate) i32);
 impl RasterizationOrderAMD {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        RasterizationOrderAMD(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1198,12 +1283,14 @@ impl RasterizationOrderAMD {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCheckEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCheckEXT.html>"]
 pub struct ValidationCheckEXT(pub(crate) i32);
 impl ValidationCheckEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ValidationCheckEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1214,12 +1301,14 @@ impl ValidationCheckEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationFeatureEnableEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFeatureEnableEXT.html>"]
 pub struct ValidationFeatureEnableEXT(pub(crate) i32);
 impl ValidationFeatureEnableEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ValidationFeatureEnableEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1233,12 +1322,14 @@ impl ValidationFeatureEnableEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationFeatureDisableEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationFeatureDisableEXT.html>"]
 pub struct ValidationFeatureDisableEXT(pub(crate) i32);
 impl ValidationFeatureDisableEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ValidationFeatureDisableEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1255,12 +1346,14 @@ impl ValidationFeatureDisableEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkIndirectCommandsTokenTypeNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkIndirectCommandsTokenTypeNV.html>"]
 pub struct IndirectCommandsTokenTypeNV(pub(crate) i32);
 impl IndirectCommandsTokenTypeNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        IndirectCommandsTokenTypeNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1277,12 +1370,14 @@ impl IndirectCommandsTokenTypeNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayPowerStateEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayPowerStateEXT.html>"]
 pub struct DisplayPowerStateEXT(pub(crate) i32);
 impl DisplayPowerStateEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DisplayPowerStateEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1294,12 +1389,14 @@ impl DisplayPowerStateEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDeviceEventTypeEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceEventTypeEXT.html>"]
 pub struct DeviceEventTypeEXT(pub(crate) i32);
 impl DeviceEventTypeEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DeviceEventTypeEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1309,12 +1406,14 @@ impl DeviceEventTypeEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDisplayEventTypeEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplayEventTypeEXT.html>"]
 pub struct DisplayEventTypeEXT(pub(crate) i32);
 impl DisplayEventTypeEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DisplayEventTypeEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1324,12 +1423,14 @@ impl DisplayEventTypeEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkViewportCoordinateSwizzleNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkViewportCoordinateSwizzleNV.html>"]
 pub struct ViewportCoordinateSwizzleNV(pub(crate) i32);
 impl ViewportCoordinateSwizzleNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ViewportCoordinateSwizzleNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1346,12 +1447,14 @@ impl ViewportCoordinateSwizzleNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDiscardRectangleModeEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDiscardRectangleModeEXT.html>"]
 pub struct DiscardRectangleModeEXT(pub(crate) i32);
 impl DiscardRectangleModeEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DiscardRectangleModeEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1362,12 +1465,14 @@ impl DiscardRectangleModeEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPointClippingBehavior.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPointClippingBehavior.html>"]
 pub struct PointClippingBehavior(pub(crate) i32);
 impl PointClippingBehavior {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PointClippingBehavior(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1378,12 +1483,14 @@ impl PointClippingBehavior {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerReductionMode.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerReductionMode.html>"]
 pub struct SamplerReductionMode(pub(crate) i32);
 impl SamplerReductionMode {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        SamplerReductionMode(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1395,12 +1502,14 @@ impl SamplerReductionMode {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkTessellationDomainOrigin.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkTessellationDomainOrigin.html>"]
 pub struct TessellationDomainOrigin(pub(crate) i32);
 impl TessellationDomainOrigin {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        TessellationDomainOrigin(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1411,12 +1520,14 @@ impl TessellationDomainOrigin {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrModelConversion.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrModelConversion.html>"]
 pub struct SamplerYcbcrModelConversion(pub(crate) i32);
 impl SamplerYcbcrModelConversion {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        SamplerYcbcrModelConversion(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1434,12 +1545,14 @@ impl SamplerYcbcrModelConversion {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkSamplerYcbcrRange.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSamplerYcbcrRange.html>"]
 pub struct SamplerYcbcrRange(pub(crate) i32);
 impl SamplerYcbcrRange {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        SamplerYcbcrRange(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1452,12 +1565,14 @@ impl SamplerYcbcrRange {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkChromaLocation.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkChromaLocation.html>"]
 pub struct ChromaLocation(pub(crate) i32);
 impl ChromaLocation {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ChromaLocation(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1468,12 +1583,14 @@ impl ChromaLocation {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBlendOverlapEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlendOverlapEXT.html>"]
 pub struct BlendOverlapEXT(pub(crate) i32);
 impl BlendOverlapEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        BlendOverlapEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1485,12 +1602,14 @@ impl BlendOverlapEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoverageModulationModeNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoverageModulationModeNV.html>"]
 pub struct CoverageModulationModeNV(pub(crate) i32);
 impl CoverageModulationModeNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        CoverageModulationModeNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1503,12 +1622,14 @@ impl CoverageModulationModeNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoverageReductionModeNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoverageReductionModeNV.html>"]
 pub struct CoverageReductionModeNV(pub(crate) i32);
 impl CoverageReductionModeNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        CoverageReductionModeNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1519,12 +1640,14 @@ impl CoverageReductionModeNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkValidationCacheHeaderVersionEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkValidationCacheHeaderVersionEXT.html>"]
 pub struct ValidationCacheHeaderVersionEXT(pub(crate) i32);
 impl ValidationCacheHeaderVersionEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ValidationCacheHeaderVersionEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1534,12 +1657,14 @@ impl ValidationCacheHeaderVersionEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderInfoTypeAMD.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderInfoTypeAMD.html>"]
 pub struct ShaderInfoTypeAMD(pub(crate) i32);
 impl ShaderInfoTypeAMD {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ShaderInfoTypeAMD(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1551,30 +1676,38 @@ impl ShaderInfoTypeAMD {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueueGlobalPriorityEXT.html>"]
-pub struct QueueGlobalPriorityEXT(pub(crate) i32);
-impl QueueGlobalPriorityEXT {
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueueGlobalPriorityKHR.html>"]
+pub struct QueueGlobalPriorityKHR(pub(crate) i32);
+impl QueueGlobalPriorityKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        QueueGlobalPriorityEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
 }
-impl QueueGlobalPriorityEXT {
+impl QueueGlobalPriorityKHR {
     pub const LOW: Self = Self(128);
     pub const MEDIUM: Self = Self(256);
     pub const HIGH: Self = Self(512);
     pub const REALTIME: Self = Self(1_024);
+    pub const LOW_EXT: Self = Self::LOW;
+    pub const MEDIUM_EXT: Self = Self::MEDIUM;
+    pub const HIGH_EXT: Self = Self::HIGH;
+    pub const REALTIME_EXT: Self = Self::REALTIME;
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkConservativeRasterizationModeEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkConservativeRasterizationModeEXT.html>"]
 pub struct ConservativeRasterizationModeEXT(pub(crate) i32);
 impl ConservativeRasterizationModeEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ConservativeRasterizationModeEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1586,12 +1719,14 @@ impl ConservativeRasterizationModeEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVendorId.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVendorId.html>"]
 pub struct VendorId(pub(crate) i32);
 impl VendorId {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        VendorId(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1609,15 +1744,19 @@ impl VendorId {
     pub const MESA: Self = Self(0x1_0005);
     #[doc = "PoCL vendor ID"]
     pub const POCL: Self = Self(0x1_0006);
+    #[doc = "Mobileye vendor ID"]
+    pub const MOBILEYE: Self = Self(0x1_0007);
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkDriverId.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDriverId.html>"]
 pub struct DriverId(pub(crate) i32);
 impl DriverId {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        DriverId(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1657,15 +1796,33 @@ impl DriverId {
     pub const JUICE_PROPRIETARY: Self = Self(16);
     #[doc = "Verisilicon, Inc."]
     pub const VERISILICON_PROPRIETARY: Self = Self(17);
+    #[doc = "Mesa open source project"]
+    pub const MESA_TURNIP: Self = Self(18);
+    #[doc = "Mesa open source project"]
+    pub const MESA_V3DV: Self = Self(19);
+    #[doc = "Mesa open source project"]
+    pub const MESA_PANVK: Self = Self(20);
+    #[doc = "Samsung Electronics Co., Ltd."]
+    pub const SAMSUNG_PROPRIETARY: Self = Self(21);
+    #[doc = "Mesa open source project"]
+    pub const MESA_VENUS: Self = Self(22);
+    #[doc = "Mesa open source project"]
+    pub const MESA_DOZEN: Self = Self(23);
+    #[doc = "Mesa open source project"]
+    pub const MESA_NVK: Self = Self(24);
+    #[doc = "Imagination Technologies"]
+    pub const IMAGINATION_OPEN_SOURCE_MESA: Self = Self(25);
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShadingRatePaletteEntryNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShadingRatePaletteEntryNV.html>"]
 pub struct ShadingRatePaletteEntryNV(pub(crate) i32);
 impl ShadingRatePaletteEntryNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ShadingRatePaletteEntryNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1686,12 +1843,14 @@ impl ShadingRatePaletteEntryNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCoarseSampleOrderTypeNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCoarseSampleOrderTypeNV.html>"]
 pub struct CoarseSampleOrderTypeNV(pub(crate) i32);
 impl CoarseSampleOrderTypeNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        CoarseSampleOrderTypeNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1704,12 +1863,14 @@ impl CoarseSampleOrderTypeNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkCopyAccelerationStructureModeKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyAccelerationStructureModeKHR.html>"]
 pub struct CopyAccelerationStructureModeKHR(pub(crate) i32);
 impl CopyAccelerationStructureModeKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        CopyAccelerationStructureModeKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1722,12 +1883,14 @@ impl CopyAccelerationStructureModeKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkBuildAccelerationStructureModeKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuildAccelerationStructureModeKHR.html>"]
 pub struct BuildAccelerationStructureModeKHR(pub(crate) i32);
 impl BuildAccelerationStructureModeKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        BuildAccelerationStructureModeKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1738,12 +1901,14 @@ impl BuildAccelerationStructureModeKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureTypeKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureTypeKHR.html>"]
 pub struct AccelerationStructureTypeKHR(pub(crate) i32);
 impl AccelerationStructureTypeKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        AccelerationStructureTypeKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1755,12 +1920,14 @@ impl AccelerationStructureTypeKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkGeometryTypeKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkGeometryTypeKHR.html>"]
 pub struct GeometryTypeKHR(pub(crate) i32);
 impl GeometryTypeKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        GeometryTypeKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1772,12 +1939,14 @@ impl GeometryTypeKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMemoryRequirementsTypeNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMemoryRequirementsTypeNV.html>"]
 pub struct AccelerationStructureMemoryRequirementsTypeNV(pub(crate) i32);
 impl AccelerationStructureMemoryRequirementsTypeNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        AccelerationStructureMemoryRequirementsTypeNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1789,12 +1958,14 @@ impl AccelerationStructureMemoryRequirementsTypeNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureBuildTypeKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureBuildTypeKHR.html>"]
 pub struct AccelerationStructureBuildTypeKHR(pub(crate) i32);
 impl AccelerationStructureBuildTypeKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        AccelerationStructureBuildTypeKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1806,12 +1977,14 @@ impl AccelerationStructureBuildTypeKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkRayTracingShaderGroupTypeKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkRayTracingShaderGroupTypeKHR.html>"]
 pub struct RayTracingShaderGroupTypeKHR(pub(crate) i32);
 impl RayTracingShaderGroupTypeKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        RayTracingShaderGroupTypeKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1823,12 +1996,14 @@ impl RayTracingShaderGroupTypeKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureCompatibilityKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureCompatibilityKHR.html>"]
 pub struct AccelerationStructureCompatibilityKHR(pub(crate) i32);
 impl AccelerationStructureCompatibilityKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        AccelerationStructureCompatibilityKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1839,12 +2014,14 @@ impl AccelerationStructureCompatibilityKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderGroupShaderKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderGroupShaderKHR.html>"]
 pub struct ShaderGroupShaderKHR(pub(crate) i32);
 impl ShaderGroupShaderKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ShaderGroupShaderKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1857,12 +2034,14 @@ impl ShaderGroupShaderKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkMemoryOverallocationBehaviorAMD.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMemoryOverallocationBehaviorAMD.html>"]
 pub struct MemoryOverallocationBehaviorAMD(pub(crate) i32);
 impl MemoryOverallocationBehaviorAMD {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        MemoryOverallocationBehaviorAMD(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1874,12 +2053,14 @@ impl MemoryOverallocationBehaviorAMD {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkScopeNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkScopeNV.html>"]
 pub struct ScopeNV(pub(crate) i32);
 impl ScopeNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ScopeNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1892,12 +2073,14 @@ impl ScopeNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkComponentTypeNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkComponentTypeNV.html>"]
 pub struct ComponentTypeNV(pub(crate) i32);
 impl ComponentTypeNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ComponentTypeNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1917,12 +2100,14 @@ impl ComponentTypeNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFullScreenExclusiveEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFullScreenExclusiveEXT.html>"]
 pub struct FullScreenExclusiveEXT(pub(crate) i32);
 impl FullScreenExclusiveEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        FullScreenExclusiveEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1935,12 +2120,14 @@ impl FullScreenExclusiveEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterScopeKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterScopeKHR.html>"]
 pub struct PerformanceCounterScopeKHR(pub(crate) i32);
 impl PerformanceCounterScopeKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PerformanceCounterScopeKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1949,18 +2136,17 @@ impl PerformanceCounterScopeKHR {
     pub const COMMAND_BUFFER: Self = Self(0);
     pub const RENDER_PASS: Self = Self(1);
     pub const COMMAND: Self = Self(2);
-    pub const QUERY_SCOPE_COMMAND_BUFFER: Self = Self::COMMAND_BUFFER;
-    pub const QUERY_SCOPE_RENDER_PASS: Self = Self::RENDER_PASS;
-    pub const QUERY_SCOPE_COMMAND: Self = Self::COMMAND;
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterUnitKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterUnitKHR.html>"]
 pub struct PerformanceCounterUnitKHR(pub(crate) i32);
 impl PerformanceCounterUnitKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PerformanceCounterUnitKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -1980,12 +2166,14 @@ impl PerformanceCounterUnitKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceCounterStorageKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceCounterStorageKHR.html>"]
 pub struct PerformanceCounterStorageKHR(pub(crate) i32);
 impl PerformanceCounterStorageKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PerformanceCounterStorageKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2000,12 +2188,14 @@ impl PerformanceCounterStorageKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceConfigurationTypeINTEL.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceConfigurationTypeINTEL.html>"]
 pub struct PerformanceConfigurationTypeINTEL(pub(crate) i32);
 impl PerformanceConfigurationTypeINTEL {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PerformanceConfigurationTypeINTEL(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2015,12 +2205,14 @@ impl PerformanceConfigurationTypeINTEL {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryPoolSamplingModeINTEL.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryPoolSamplingModeINTEL.html>"]
 pub struct QueryPoolSamplingModeINTEL(pub(crate) i32);
 impl QueryPoolSamplingModeINTEL {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        QueryPoolSamplingModeINTEL(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2030,12 +2222,14 @@ impl QueryPoolSamplingModeINTEL {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceOverrideTypeINTEL.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceOverrideTypeINTEL.html>"]
 pub struct PerformanceOverrideTypeINTEL(pub(crate) i32);
 impl PerformanceOverrideTypeINTEL {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PerformanceOverrideTypeINTEL(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2046,12 +2240,14 @@ impl PerformanceOverrideTypeINTEL {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceParameterTypeINTEL.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceParameterTypeINTEL.html>"]
 pub struct PerformanceParameterTypeINTEL(pub(crate) i32);
 impl PerformanceParameterTypeINTEL {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PerformanceParameterTypeINTEL(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2062,12 +2258,14 @@ impl PerformanceParameterTypeINTEL {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPerformanceValueTypeINTEL.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPerformanceValueTypeINTEL.html>"]
 pub struct PerformanceValueTypeINTEL(pub(crate) i32);
 impl PerformanceValueTypeINTEL {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PerformanceValueTypeINTEL(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2081,12 +2279,14 @@ impl PerformanceValueTypeINTEL {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkShaderFloatControlsIndependence.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderFloatControlsIndependence.html>"]
 pub struct ShaderFloatControlsIndependence(pub(crate) i32);
 impl ShaderFloatControlsIndependence {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ShaderFloatControlsIndependence(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2098,12 +2298,14 @@ impl ShaderFloatControlsIndependence {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkPipelineExecutableStatisticFormatKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineExecutableStatisticFormatKHR.html>"]
 pub struct PipelineExecutableStatisticFormatKHR(pub(crate) i32);
 impl PipelineExecutableStatisticFormatKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        PipelineExecutableStatisticFormatKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2116,12 +2318,14 @@ impl PipelineExecutableStatisticFormatKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkLineRasterizationModeEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLineRasterizationModeEXT.html>"]
 pub struct LineRasterizationModeEXT(pub(crate) i32);
 impl LineRasterizationModeEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        LineRasterizationModeEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2134,12 +2338,14 @@ impl LineRasterizationModeEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFragmentShadingRateCombinerOpKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFragmentShadingRateCombinerOpKHR.html>"]
 pub struct FragmentShadingRateCombinerOpKHR(pub(crate) i32);
 impl FragmentShadingRateCombinerOpKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        FragmentShadingRateCombinerOpKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2153,12 +2359,14 @@ impl FragmentShadingRateCombinerOpKHR {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFragmentShadingRateNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFragmentShadingRateNV.html>"]
 pub struct FragmentShadingRateNV(pub(crate) i32);
 impl FragmentShadingRateNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        FragmentShadingRateNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2179,12 +2387,14 @@ impl FragmentShadingRateNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkFragmentShadingRateTypeNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFragmentShadingRateTypeNV.html>"]
 pub struct FragmentShadingRateTypeNV(pub(crate) i32);
 impl FragmentShadingRateTypeNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        FragmentShadingRateTypeNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2195,12 +2405,44 @@ impl FragmentShadingRateTypeNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkProvokingVertexModeEXT.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSubpassMergeStatusEXT.html>"]
+pub struct SubpassMergeStatusEXT(pub(crate) i32);
+impl SubpassMergeStatusEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl SubpassMergeStatusEXT {
+    pub const MERGED: Self = Self(0);
+    pub const DISALLOWED: Self = Self(1);
+    pub const NOT_MERGED_SIDE_EFFECTS: Self = Self(2);
+    pub const NOT_MERGED_SAMPLES_MISMATCH: Self = Self(3);
+    pub const NOT_MERGED_VIEWS_MISMATCH: Self = Self(4);
+    pub const NOT_MERGED_ALIASING: Self = Self(5);
+    pub const NOT_MERGED_DEPENDENCIES: Self = Self(6);
+    pub const NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT: Self = Self(7);
+    pub const NOT_MERGED_TOO_MANY_ATTACHMENTS: Self = Self(8);
+    pub const NOT_MERGED_INSUFFICIENT_STORAGE: Self = Self(9);
+    pub const NOT_MERGED_DEPTH_STENCIL_COUNT: Self = Self(10);
+    pub const NOT_MERGED_RESOLVE_ATTACHMENT_REUSE: Self = Self(11);
+    pub const NOT_MERGED_SINGLE_SUBPASS: Self = Self(12);
+    pub const NOT_MERGED_UNSPECIFIED: Self = Self(13);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkProvokingVertexModeEXT.html>"]
 pub struct ProvokingVertexModeEXT(pub(crate) i32);
 impl ProvokingVertexModeEXT {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        ProvokingVertexModeEXT(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2211,12 +2453,14 @@ impl ProvokingVertexModeEXT {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkAccelerationStructureMotionInstanceTypeNV.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureMotionInstanceTypeNV.html>"]
 pub struct AccelerationStructureMotionInstanceTypeNV(pub(crate) i32);
 impl AccelerationStructureMotionInstanceTypeNV {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        AccelerationStructureMotionInstanceTypeNV(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2228,12 +2472,32 @@ impl AccelerationStructureMotionInstanceTypeNV {
 }
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
-#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkQueryResultStatusKHR.html>"]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceAddressBindingTypeEXT.html>"]
+pub struct DeviceAddressBindingTypeEXT(pub(crate) i32);
+impl DeviceAddressBindingTypeEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl DeviceAddressBindingTypeEXT {
+    pub const BIND: Self = Self(0);
+    pub const UNBIND: Self = Self(1);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkQueryResultStatusKHR.html>"]
 pub struct QueryResultStatusKHR(pub(crate) i32);
 impl QueryResultStatusKHR {
+    #[inline]
     pub const fn from_raw(x: i32) -> Self {
-        QueryResultStatusKHR(x)
+        Self(x)
     }
+    #[inline]
     pub const fn as_raw(self) -> i32 {
         self.0
     }
@@ -2243,3 +2507,459 @@ impl QueryResultStatusKHR {
     pub const NOT_READY: Self = Self(0);
     pub const COMPLETE: Self = Self(1);
 }
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeTuningModeKHR.html>"]
+pub struct VideoEncodeTuningModeKHR(pub(crate) i32);
+impl VideoEncodeTuningModeKHR {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl VideoEncodeTuningModeKHR {
+    pub const DEFAULT: Self = Self(0);
+    pub const HIGH_QUALITY: Self = Self(1);
+    pub const LOW_LATENCY: Self = Self(2);
+    pub const ULTRA_LOW_LATENCY: Self = Self(3);
+    pub const LOSSLESS: Self = Self(4);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlStructureEXT.html>"]
+pub struct VideoEncodeH264RateControlStructureEXT(pub(crate) i32);
+impl VideoEncodeH264RateControlStructureEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl VideoEncodeH264RateControlStructureEXT {
+    pub const UNKNOWN: Self = Self(0);
+    pub const FLAT: Self = Self(1);
+    pub const DYADIC: Self = Self(2);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlStructureEXT.html>"]
+pub struct VideoEncodeH265RateControlStructureEXT(pub(crate) i32);
+impl VideoEncodeH265RateControlStructureEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl VideoEncodeH265RateControlStructureEXT {
+    pub const UNKNOWN: Self = Self(0);
+    pub const FLAT: Self = Self(1);
+    pub const DYADIC: Self = Self(2);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRobustnessBufferBehaviorEXT.html>"]
+pub struct PipelineRobustnessBufferBehaviorEXT(pub(crate) i32);
+impl PipelineRobustnessBufferBehaviorEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl PipelineRobustnessBufferBehaviorEXT {
+    pub const DEVICE_DEFAULT: Self = Self(0);
+    pub const DISABLED: Self = Self(1);
+    pub const ROBUST_BUFFER_ACCESS: Self = Self(2);
+    pub const ROBUST_BUFFER_ACCESS_2: Self = Self(3);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRobustnessImageBehaviorEXT.html>"]
+pub struct PipelineRobustnessImageBehaviorEXT(pub(crate) i32);
+impl PipelineRobustnessImageBehaviorEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl PipelineRobustnessImageBehaviorEXT {
+    pub const DEVICE_DEFAULT: Self = Self(0);
+    pub const DISABLED: Self = Self(1);
+    pub const ROBUST_IMAGE_ACCESS: Self = Self(2);
+    pub const ROBUST_IMAGE_ACCESS_2: Self = Self(3);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowPerformanceLevelNV.html>"]
+pub struct OpticalFlowPerformanceLevelNV(pub(crate) i32);
+impl OpticalFlowPerformanceLevelNV {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl OpticalFlowPerformanceLevelNV {
+    pub const UNKNOWN: Self = Self(0);
+    pub const SLOW: Self = Self(1);
+    pub const MEDIUM: Self = Self(2);
+    pub const FAST: Self = Self(3);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpticalFlowSessionBindingPointNV.html>"]
+pub struct OpticalFlowSessionBindingPointNV(pub(crate) i32);
+impl OpticalFlowSessionBindingPointNV {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl OpticalFlowSessionBindingPointNV {
+    pub const UNKNOWN: Self = Self(0);
+    pub const INPUT: Self = Self(1);
+    pub const REFERENCE: Self = Self(2);
+    pub const HINT: Self = Self(3);
+    pub const FLOW_VECTOR: Self = Self(4);
+    pub const BACKWARD_FLOW_VECTOR: Self = Self(5);
+    pub const COST: Self = Self(6);
+    pub const BACKWARD_COST: Self = Self(7);
+    pub const GLOBAL_FLOW: Self = Self(8);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkMicromapTypeEXT.html>"]
+pub struct MicromapTypeEXT(pub(crate) i32);
+impl MicromapTypeEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl MicromapTypeEXT {
+    pub const OPACITY_MICROMAP: Self = Self(0);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCopyMicromapModeEXT.html>"]
+pub struct CopyMicromapModeEXT(pub(crate) i32);
+impl CopyMicromapModeEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl CopyMicromapModeEXT {
+    pub const CLONE: Self = Self(0);
+    pub const SERIALIZE: Self = Self(1);
+    pub const DESERIALIZE: Self = Self(2);
+    pub const COMPACT: Self = Self(3);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBuildMicromapModeEXT.html>"]
+pub struct BuildMicromapModeEXT(pub(crate) i32);
+impl BuildMicromapModeEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl BuildMicromapModeEXT {
+    pub const BUILD: Self = Self(0);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpacityMicromapFormatEXT.html>"]
+pub struct OpacityMicromapFormatEXT(pub(crate) i32);
+impl OpacityMicromapFormatEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl OpacityMicromapFormatEXT {
+    pub const TYPE_2_STATE: Self = Self(1);
+    pub const TYPE_4_STATE: Self = Self(2);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOpacityMicromapSpecialIndexEXT.html>"]
+pub struct OpacityMicromapSpecialIndexEXT(pub(crate) i32);
+impl OpacityMicromapSpecialIndexEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl OpacityMicromapSpecialIndexEXT {
+    pub const FULLY_TRANSPARENT: Self = Self(-1);
+    pub const FULLY_OPAQUE: Self = Self(-2);
+    pub const FULLY_UNKNOWN_TRANSPARENT: Self = Self(-3);
+    pub const FULLY_UNKNOWN_OPAQUE: Self = Self(-4);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultAddressTypeEXT.html>"]
+pub struct DeviceFaultAddressTypeEXT(pub(crate) i32);
+impl DeviceFaultAddressTypeEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl DeviceFaultAddressTypeEXT {
+    #[doc = "Currently unused"]
+    pub const NONE: Self = Self(0);
+    pub const READ_INVALID: Self = Self(1);
+    pub const WRITE_INVALID: Self = Self(2);
+    pub const EXECUTE_INVALID: Self = Self(3);
+    pub const INSTRUCTION_POINTER_UNKNOWN: Self = Self(4);
+    pub const INSTRUCTION_POINTER_INVALID: Self = Self(5);
+    pub const INSTRUCTION_POINTER_FAULT: Self = Self(6);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultVendorBinaryHeaderVersionEXT.html>"]
+pub struct DeviceFaultVendorBinaryHeaderVersionEXT(pub(crate) i32);
+impl DeviceFaultVendorBinaryHeaderVersionEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl DeviceFaultVendorBinaryHeaderVersionEXT {
+    pub const ONE: Self = Self(1);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDisplacementMicromapFormatNV.html>"]
+pub struct DisplacementMicromapFormatNV(pub(crate) i32);
+impl DisplacementMicromapFormatNV {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl DisplacementMicromapFormatNV {
+    pub const TYPE_64_TRIANGLES_64_BYTES: Self = Self(1);
+    pub const TYPE_256_TRIANGLES_128_BYTES: Self = Self(2);
+    pub const TYPE_1024_TRIANGLES_128_BYTES: Self = Self(3);
+}
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkShaderCodeTypeEXT.html>"]
+pub struct ShaderCodeTypeEXT(pub(crate) i32);
+impl ShaderCodeTypeEXT {
+    #[inline]
+    pub const fn from_raw(x: i32) -> Self {
+        Self(x)
+    }
+    #[inline]
+    pub const fn as_raw(self) -> i32 {
+        self.0
+    }
+}
+impl ShaderCodeTypeEXT {
+    pub const BINARY: Self = Self(0);
+    pub const SPIRV: Self = Self(1);
+}
+impl fmt::Debug for ObjectType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::UNKNOWN => Some("UNKNOWN"),
+            Self::INSTANCE => Some("INSTANCE"),
+            Self::PHYSICAL_DEVICE => Some("PHYSICAL_DEVICE"),
+            Self::DEVICE => Some("DEVICE"),
+            Self::QUEUE => Some("QUEUE"),
+            Self::SEMAPHORE => Some("SEMAPHORE"),
+            Self::COMMAND_BUFFER => Some("COMMAND_BUFFER"),
+            Self::FENCE => Some("FENCE"),
+            Self::DEVICE_MEMORY => Some("DEVICE_MEMORY"),
+            Self::BUFFER => Some("BUFFER"),
+            Self::IMAGE => Some("IMAGE"),
+            Self::EVENT => Some("EVENT"),
+            Self::QUERY_POOL => Some("QUERY_POOL"),
+            Self::BUFFER_VIEW => Some("BUFFER_VIEW"),
+            Self::IMAGE_VIEW => Some("IMAGE_VIEW"),
+            Self::SHADER_MODULE => Some("SHADER_MODULE"),
+            Self::PIPELINE_CACHE => Some("PIPELINE_CACHE"),
+            Self::PIPELINE_LAYOUT => Some("PIPELINE_LAYOUT"),
+            Self::RENDER_PASS => Some("RENDER_PASS"),
+            Self::PIPELINE => Some("PIPELINE"),
+            Self::DESCRIPTOR_SET_LAYOUT => Some("DESCRIPTOR_SET_LAYOUT"),
+            Self::SAMPLER => Some("SAMPLER"),
+            Self::DESCRIPTOR_POOL => Some("DESCRIPTOR_POOL"),
+            Self::DESCRIPTOR_SET => Some("DESCRIPTOR_SET"),
+            Self::FRAMEBUFFER => Some("FRAMEBUFFER"),
+            Self::COMMAND_POOL => Some("COMMAND_POOL"),
+            Self::SURFACE_KHR => Some("SURFACE_KHR"),
+            Self::SWAPCHAIN_KHR => Some("SWAPCHAIN_KHR"),
+            Self::DISPLAY_KHR => Some("DISPLAY_KHR"),
+            Self::DISPLAY_MODE_KHR => Some("DISPLAY_MODE_KHR"),
+            Self::DEBUG_REPORT_CALLBACK_EXT => Some("DEBUG_REPORT_CALLBACK_EXT"),
+            Self::VIDEO_SESSION_KHR => Some("VIDEO_SESSION_KHR"),
+            Self::VIDEO_SESSION_PARAMETERS_KHR => Some("VIDEO_SESSION_PARAMETERS_KHR"),
+            Self::CU_MODULE_NVX => Some("CU_MODULE_NVX"),
+            Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"),
+            Self::DEBUG_UTILS_MESSENGER_EXT => Some("DEBUG_UTILS_MESSENGER_EXT"),
+            Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"),
+            Self::VALIDATION_CACHE_EXT => Some("VALIDATION_CACHE_EXT"),
+            Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"),
+            Self::PERFORMANCE_CONFIGURATION_INTEL => Some("PERFORMANCE_CONFIGURATION_INTEL"),
+            Self::DEFERRED_OPERATION_KHR => Some("DEFERRED_OPERATION_KHR"),
+            Self::INDIRECT_COMMANDS_LAYOUT_NV => Some("INDIRECT_COMMANDS_LAYOUT_NV"),
+            Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"),
+            Self::MICROMAP_EXT => Some("MICROMAP_EXT"),
+            Self::OPTICAL_FLOW_SESSION_NV => Some("OPTICAL_FLOW_SESSION_NV"),
+            Self::SHADER_EXT => Some("SHADER_EXT"),
+            Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"),
+            Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"),
+            Self::PRIVATE_DATA_SLOT => Some("PRIVATE_DATA_SLOT"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+impl fmt::Debug for Result {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let name = match *self {
+            Self::SUCCESS => Some("SUCCESS"),
+            Self::NOT_READY => Some("NOT_READY"),
+            Self::TIMEOUT => Some("TIMEOUT"),
+            Self::EVENT_SET => Some("EVENT_SET"),
+            Self::EVENT_RESET => Some("EVENT_RESET"),
+            Self::INCOMPLETE => Some("INCOMPLETE"),
+            Self::ERROR_OUT_OF_HOST_MEMORY => Some("ERROR_OUT_OF_HOST_MEMORY"),
+            Self::ERROR_OUT_OF_DEVICE_MEMORY => Some("ERROR_OUT_OF_DEVICE_MEMORY"),
+            Self::ERROR_INITIALIZATION_FAILED => Some("ERROR_INITIALIZATION_FAILED"),
+            Self::ERROR_DEVICE_LOST => Some("ERROR_DEVICE_LOST"),
+            Self::ERROR_MEMORY_MAP_FAILED => Some("ERROR_MEMORY_MAP_FAILED"),
+            Self::ERROR_LAYER_NOT_PRESENT => Some("ERROR_LAYER_NOT_PRESENT"),
+            Self::ERROR_EXTENSION_NOT_PRESENT => Some("ERROR_EXTENSION_NOT_PRESENT"),
+            Self::ERROR_FEATURE_NOT_PRESENT => Some("ERROR_FEATURE_NOT_PRESENT"),
+            Self::ERROR_INCOMPATIBLE_DRIVER => Some("ERROR_INCOMPATIBLE_DRIVER"),
+            Self::ERROR_TOO_MANY_OBJECTS => Some("ERROR_TOO_MANY_OBJECTS"),
+            Self::ERROR_FORMAT_NOT_SUPPORTED => Some("ERROR_FORMAT_NOT_SUPPORTED"),
+            Self::ERROR_FRAGMENTED_POOL => Some("ERROR_FRAGMENTED_POOL"),
+            Self::ERROR_UNKNOWN => Some("ERROR_UNKNOWN"),
+            Self::ERROR_SURFACE_LOST_KHR => Some("ERROR_SURFACE_LOST_KHR"),
+            Self::ERROR_NATIVE_WINDOW_IN_USE_KHR => Some("ERROR_NATIVE_WINDOW_IN_USE_KHR"),
+            Self::SUBOPTIMAL_KHR => Some("SUBOPTIMAL_KHR"),
+            Self::ERROR_OUT_OF_DATE_KHR => Some("ERROR_OUT_OF_DATE_KHR"),
+            Self::ERROR_INCOMPATIBLE_DISPLAY_KHR => Some("ERROR_INCOMPATIBLE_DISPLAY_KHR"),
+            Self::ERROR_VALIDATION_FAILED_EXT => Some("ERROR_VALIDATION_FAILED_EXT"),
+            Self::ERROR_INVALID_SHADER_NV => Some("ERROR_INVALID_SHADER_NV"),
+            Self::ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR => {
+                Some("ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR")
+            }
+            Self::ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR => {
+                Some("ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR")
+            }
+            Self::ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR => {
+                Some("ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR")
+            }
+            Self::ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR => {
+                Some("ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR")
+            }
+            Self::ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR => {
+                Some("ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR")
+            }
+            Self::ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR => {
+                Some("ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR")
+            }
+            Self::ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT => {
+                Some("ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT")
+            }
+            Self::ERROR_NOT_PERMITTED_KHR => Some("ERROR_NOT_PERMITTED_KHR"),
+            Self::ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT => {
+                Some("ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT")
+            }
+            Self::THREAD_IDLE_KHR => Some("THREAD_IDLE_KHR"),
+            Self::THREAD_DONE_KHR => Some("THREAD_DONE_KHR"),
+            Self::OPERATION_DEFERRED_KHR => Some("OPERATION_DEFERRED_KHR"),
+            Self::OPERATION_NOT_DEFERRED_KHR => Some("OPERATION_NOT_DEFERRED_KHR"),
+            Self::ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR => {
+                Some("ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR")
+            }
+            Self::ERROR_COMPRESSION_EXHAUSTED_EXT => Some("ERROR_COMPRESSION_EXHAUSTED_EXT"),
+            Self::ERROR_INCOMPATIBLE_SHADER_BINARY_EXT => {
+                Some("ERROR_INCOMPATIBLE_SHADER_BINARY_EXT")
+            }
+            Self::ERROR_OUT_OF_POOL_MEMORY => Some("ERROR_OUT_OF_POOL_MEMORY"),
+            Self::ERROR_INVALID_EXTERNAL_HANDLE => Some("ERROR_INVALID_EXTERNAL_HANDLE"),
+            Self::ERROR_FRAGMENTATION => Some("ERROR_FRAGMENTATION"),
+            Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS => {
+                Some("ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS")
+            }
+            Self::PIPELINE_COMPILE_REQUIRED => Some("PIPELINE_COMPILE_REQUIRED"),
+            _ => None,
+        };
+        if let Some(x) = name {
+            f.write_str(x)
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
diff --git a/src/vk/extensions.rs b/src/vk/extensions.rs
index 449f138..47ccd9b 100644
--- a/src/vk/extensions.rs
+++ b/src/vk/extensions.rs
@@ -5,8 +5,9 @@ use crate::vk::enums::*;
 use crate::vk::platform_types::*;
 use std::os::raw::*;
 impl KhrSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_surface\0").expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 25u32;
 }
@@ -59,7 +60,7 @@ impl KhrSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSurfaceFn {
+        Self {
             destroy_surface_khr: unsafe {
                 unsafe extern "system" fn destroy_surface_khr(
                     _instance: Instance,
@@ -166,90 +167,20 @@ impl KhrSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySurfaceKHR.html>"]
-    pub unsafe fn destroy_surface_khr(
-        &self,
-        instance: Instance,
-        surface: SurfaceKHR,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_surface_khr)(instance, surface, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html>"]
-    pub unsafe fn get_physical_device_surface_support_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        queue_family_index: u32,
-        surface: SurfaceKHR,
-        p_supported: *mut Bool32,
-    ) -> Result {
-        (self.get_physical_device_surface_support_khr)(
-            physical_device,
-            queue_family_index,
-            surface,
-            p_supported,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html>"]
-    pub unsafe fn get_physical_device_surface_capabilities_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        surface: SurfaceKHR,
-        p_surface_capabilities: *mut SurfaceCapabilitiesKHR,
-    ) -> Result {
-        (self.get_physical_device_surface_capabilities_khr)(
-            physical_device,
-            surface,
-            p_surface_capabilities,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html>"]
-    pub unsafe fn get_physical_device_surface_formats_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        surface: SurfaceKHR,
-        p_surface_format_count: *mut u32,
-        p_surface_formats: *mut SurfaceFormatKHR,
-    ) -> Result {
-        (self.get_physical_device_surface_formats_khr)(
-            physical_device,
-            surface,
-            p_surface_format_count,
-            p_surface_formats,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html>"]
-    pub unsafe fn get_physical_device_surface_present_modes_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        surface: SurfaceKHR,
-        p_present_mode_count: *mut u32,
-        p_present_modes: *mut PresentModeKHR,
-    ) -> Result {
-        (self.get_physical_device_surface_present_modes_khr)(
-            physical_device,
-            surface,
-            p_present_mode_count,
-            p_present_modes,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_surface'"]
-impl Result {
-    pub const ERROR_SURFACE_LOST_KHR: Self = Self(-1000000000);
+impl ObjectType {
+    pub const SURFACE_KHR: Self = Self(1_000_000_000);
 }
 #[doc = "Generated from 'VK_KHR_surface'"]
 impl Result {
-    pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Self(-1000000001);
-}
-#[doc = "Generated from 'VK_KHR_surface'"]
-impl ObjectType {
-    pub const SURFACE_KHR: Self = Self(1_000_000_000);
+    pub const ERROR_SURFACE_LOST_KHR: Self = Self(-1_000_000_000);
+    pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Self(-1_000_000_001);
 }
 impl KhrSwapchainFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_swapchain\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain\0") }
     }
     pub const SPEC_VERSION: u32 = 70u32;
 }
@@ -328,7 +259,7 @@ impl KhrSwapchainFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSwapchainFn {
+        Self {
             create_swapchain_khr: unsafe {
                 unsafe extern "system" fn create_swapchain_khr(
                     _device: Device,
@@ -511,164 +442,42 @@ impl KhrSwapchainFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSwapchainKHR.html>"]
-    pub unsafe fn create_swapchain_khr(
-        &self,
-        device: Device,
-        p_create_info: *const SwapchainCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_swapchain: *mut SwapchainKHR,
-    ) -> Result {
-        (self.create_swapchain_khr)(device, p_create_info, p_allocator, p_swapchain)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySwapchainKHR.html>"]
-    pub unsafe fn destroy_swapchain_khr(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_swapchain_khr)(device, swapchain, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSwapchainImagesKHR.html>"]
-    pub unsafe fn get_swapchain_images_khr(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-        p_swapchain_image_count: *mut u32,
-        p_swapchain_images: *mut Image,
-    ) -> Result {
-        (self.get_swapchain_images_khr)(
-            device,
-            swapchain,
-            p_swapchain_image_count,
-            p_swapchain_images,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireNextImageKHR.html>"]
-    pub unsafe fn acquire_next_image_khr(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-        timeout: u64,
-        semaphore: Semaphore,
-        fence: Fence,
-        p_image_index: *mut u32,
-    ) -> Result {
-        (self.acquire_next_image_khr)(device, swapchain, timeout, semaphore, fence, p_image_index)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueuePresentKHR.html>"]
-    pub unsafe fn queue_present_khr(
-        &self,
-        queue: Queue,
-        p_present_info: *const PresentInfoKHR,
-    ) -> Result {
-        (self.queue_present_khr)(queue, p_present_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html>"]
-    pub unsafe fn get_device_group_present_capabilities_khr(
-        &self,
-        device: Device,
-        p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR,
-    ) -> Result {
-        (self.get_device_group_present_capabilities_khr)(
-            device,
-            p_device_group_present_capabilities,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html>"]
-    pub unsafe fn get_device_group_surface_present_modes_khr(
-        &self,
-        device: Device,
-        surface: SurfaceKHR,
-        p_modes: *mut DeviceGroupPresentModeFlagsKHR,
-    ) -> Result {
-        (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html>"]
-    pub unsafe fn get_physical_device_present_rectangles_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        surface: SurfaceKHR,
-        p_rect_count: *mut u32,
-        p_rects: *mut Rect2D,
-    ) -> Result {
-        (self.get_physical_device_present_rectangles_khr)(
-            physical_device,
-            surface,
-            p_rect_count,
-            p_rects,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireNextImage2KHR.html>"]
-    pub unsafe fn acquire_next_image2_khr(
-        &self,
-        device: Device,
-        p_acquire_info: *const AcquireNextImageInfoKHR,
-        p_image_index: *mut u32,
-    ) -> Result {
-        (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index)
-    }
-}
-#[doc = "Generated from 'VK_KHR_swapchain'"]
-impl StructureType {
-    pub const SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_001_000);
-}
-#[doc = "Generated from 'VK_KHR_swapchain'"]
-impl StructureType {
-    pub const PRESENT_INFO_KHR: Self = Self(1_000_001_001);
 }
 #[doc = "Generated from 'VK_KHR_swapchain'"]
 impl ImageLayout {
     pub const PRESENT_SRC_KHR: Self = Self(1_000_001_002);
 }
 #[doc = "Generated from 'VK_KHR_swapchain'"]
-impl Result {
-    pub const SUBOPTIMAL_KHR: Self = Self(1_000_001_003);
-}
-#[doc = "Generated from 'VK_KHR_swapchain'"]
-impl Result {
-    pub const ERROR_OUT_OF_DATE_KHR: Self = Self(-1000001004);
-}
-#[doc = "Generated from 'VK_KHR_swapchain'"]
 impl ObjectType {
     pub const SWAPCHAIN_KHR: Self = Self(1_000_001_000);
 }
 #[doc = "Generated from 'VK_KHR_swapchain'"]
-impl StructureType {
-    pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = Self(1_000_060_007);
+impl Result {
+    pub const SUBOPTIMAL_KHR: Self = Self(1_000_001_003);
+    pub const ERROR_OUT_OF_DATE_KHR: Self = Self(-1_000_001_004);
 }
 #[doc = "Generated from 'VK_KHR_swapchain'"]
 impl StructureType {
+    pub const SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_001_000);
+    pub const PRESENT_INFO_KHR: Self = Self(1_000_001_001);
+    pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = Self(1_000_060_007);
     pub const IMAGE_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_008);
-}
-#[doc = "Generated from 'VK_KHR_swapchain'"]
-impl StructureType {
     pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: Self = Self(1_000_060_009);
-}
-#[doc = "Generated from 'VK_KHR_swapchain'"]
-impl StructureType {
     pub const ACQUIRE_NEXT_IMAGE_INFO_KHR: Self = Self(1_000_060_010);
-}
-#[doc = "Generated from 'VK_KHR_swapchain'"]
-impl StructureType {
     pub const DEVICE_GROUP_PRESENT_INFO_KHR: Self = Self(1_000_060_011);
-}
-#[doc = "Generated from 'VK_KHR_swapchain'"]
-impl StructureType {
     pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_012);
 }
 #[doc = "Generated from 'VK_KHR_swapchain'"]
 impl SwapchainCreateFlagsKHR {
+    #[doc = "Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"]
     pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(0b1);
-}
-#[doc = "Generated from 'VK_KHR_swapchain'"]
-impl SwapchainCreateFlagsKHR {
+    #[doc = "Swapchain is protected"]
     pub const PROTECTED: Self = Self(0b10);
 }
 impl KhrDisplayFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_display\0").expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display\0") }
     }
     pub const SPEC_VERSION: u32 = 23u32;
 }
@@ -738,7 +547,7 @@ impl KhrDisplayFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDisplayFn {
+        Self {
             get_physical_device_display_properties_khr: unsafe {
                 unsafe extern "system" fn get_physical_device_display_properties_khr(
                     _physical_device: PhysicalDevice,
@@ -893,119 +702,21 @@ impl KhrDisplayFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html>"]
-    pub unsafe fn get_physical_device_display_properties_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_property_count: *mut u32,
-        p_properties: *mut DisplayPropertiesKHR,
-    ) -> Result {
-        (self.get_physical_device_display_properties_khr)(
-            physical_device,
-            p_property_count,
-            p_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html>"]
-    pub unsafe fn get_physical_device_display_plane_properties_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_property_count: *mut u32,
-        p_properties: *mut DisplayPlanePropertiesKHR,
-    ) -> Result {
-        (self.get_physical_device_display_plane_properties_khr)(
-            physical_device,
-            p_property_count,
-            p_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html>"]
-    pub unsafe fn get_display_plane_supported_displays_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        plane_index: u32,
-        p_display_count: *mut u32,
-        p_displays: *mut DisplayKHR,
-    ) -> Result {
-        (self.get_display_plane_supported_displays_khr)(
-            physical_device,
-            plane_index,
-            p_display_count,
-            p_displays,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayModePropertiesKHR.html>"]
-    pub unsafe fn get_display_mode_properties_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        display: DisplayKHR,
-        p_property_count: *mut u32,
-        p_properties: *mut DisplayModePropertiesKHR,
-    ) -> Result {
-        (self.get_display_mode_properties_khr)(
-            physical_device,
-            display,
-            p_property_count,
-            p_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDisplayModeKHR.html>"]
-    pub unsafe fn create_display_mode_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        display: DisplayKHR,
-        p_create_info: *const DisplayModeCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_mode: *mut DisplayModeKHR,
-    ) -> Result {
-        (self.create_display_mode_khr)(physical_device, display, p_create_info, p_allocator, p_mode)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayPlaneCapabilitiesKHR.html>"]
-    pub unsafe fn get_display_plane_capabilities_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        mode: DisplayModeKHR,
-        plane_index: u32,
-        p_capabilities: *mut DisplayPlaneCapabilitiesKHR,
-    ) -> Result {
-        (self.get_display_plane_capabilities_khr)(
-            physical_device,
-            mode,
-            plane_index,
-            p_capabilities,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDisplayPlaneSurfaceKHR.html>"]
-    pub unsafe fn create_display_plane_surface_khr(
-        &self,
-        instance: Instance,
-        p_create_info: *const DisplaySurfaceCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_display_plane_surface_khr)(instance, p_create_info, p_allocator, p_surface)
-    }
-}
-#[doc = "Generated from 'VK_KHR_display'"]
-impl StructureType {
-    pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = Self(1_000_002_000);
-}
-#[doc = "Generated from 'VK_KHR_display'"]
-impl StructureType {
-    pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_002_001);
 }
 #[doc = "Generated from 'VK_KHR_display'"]
 impl ObjectType {
     pub const DISPLAY_KHR: Self = Self(1_000_002_000);
+    pub const DISPLAY_MODE_KHR: Self = Self(1_000_002_001);
 }
 #[doc = "Generated from 'VK_KHR_display'"]
-impl ObjectType {
-    pub const DISPLAY_MODE_KHR: Self = Self(1_000_002_001);
+impl StructureType {
+    pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = Self(1_000_002_000);
+    pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_002_001);
 }
 impl KhrDisplaySwapchainFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_display_swapchain\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display_swapchain\0") }
     }
     pub const SPEC_VERSION: u32 = 10u32;
 }
@@ -1028,7 +739,7 @@ impl KhrDisplaySwapchainFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDisplaySwapchainFn {
+        Self {
             create_shared_swapchains_khr: unsafe {
                 unsafe extern "system" fn create_shared_swapchains_khr(
                     _device: Device,
@@ -1054,36 +765,19 @@ impl KhrDisplaySwapchainFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSharedSwapchainsKHR.html>"]
-    pub unsafe fn create_shared_swapchains_khr(
-        &self,
-        device: Device,
-        swapchain_count: u32,
-        p_create_infos: *const SwapchainCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_swapchains: *mut SwapchainKHR,
-    ) -> Result {
-        (self.create_shared_swapchains_khr)(
-            device,
-            swapchain_count,
-            p_create_infos,
-            p_allocator,
-            p_swapchains,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_display_swapchain'"]
-impl StructureType {
-    pub const DISPLAY_PRESENT_INFO_KHR: Self = Self(1_000_003_000);
+impl Result {
+    pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Self(-1_000_003_001);
 }
 #[doc = "Generated from 'VK_KHR_display_swapchain'"]
-impl Result {
-    pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Self(-1000003001);
+impl StructureType {
+    pub const DISPLAY_PRESENT_INFO_KHR: Self = Self(1_000_003_000);
 }
 impl KhrXlibSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_xlib_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xlib_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 6u32;
 }
@@ -1114,7 +808,7 @@ impl KhrXlibSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrXlibSurfaceFn {
+        Self {
             create_xlib_surface_khr: unsafe {
                 unsafe extern "system" fn create_xlib_surface_khr(
                     _instance: Instance,
@@ -1160,40 +854,15 @@ impl KhrXlibSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateXlibSurfaceKHR.html>"]
-    pub unsafe fn create_xlib_surface_khr(
-        &self,
-        instance: Instance,
-        p_create_info: *const XlibSurfaceCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_xlib_surface_khr)(instance, p_create_info, p_allocator, p_surface)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html>"]
-    pub unsafe fn get_physical_device_xlib_presentation_support_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        queue_family_index: u32,
-        dpy: *mut Display,
-        visual_id: VisualID,
-    ) -> Bool32 {
-        (self.get_physical_device_xlib_presentation_support_khr)(
-            physical_device,
-            queue_family_index,
-            dpy,
-            visual_id,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_xlib_surface'"]
 impl StructureType {
     pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_004_000);
 }
 impl KhrXcbSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_xcb_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xcb_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 6u32;
 }
@@ -1224,7 +893,7 @@ impl KhrXcbSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrXcbSurfaceFn {
+        Self {
             create_xcb_surface_khr: unsafe {
                 unsafe extern "system" fn create_xcb_surface_khr(
                     _instance: Instance,
@@ -1270,40 +939,15 @@ impl KhrXcbSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateXcbSurfaceKHR.html>"]
-    pub unsafe fn create_xcb_surface_khr(
-        &self,
-        instance: Instance,
-        p_create_info: *const XcbSurfaceCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_xcb_surface_khr)(instance, p_create_info, p_allocator, p_surface)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html>"]
-    pub unsafe fn get_physical_device_xcb_presentation_support_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        queue_family_index: u32,
-        connection: *mut xcb_connection_t,
-        visual_id: xcb_visualid_t,
-    ) -> Bool32 {
-        (self.get_physical_device_xcb_presentation_support_khr)(
-            physical_device,
-            queue_family_index,
-            connection,
-            visual_id,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_xcb_surface'"]
 impl StructureType {
     pub const XCB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_005_000);
 }
 impl KhrWaylandSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_wayland_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_wayland_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 6u32;
 }
@@ -1334,7 +978,7 @@ impl KhrWaylandSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrWaylandSurfaceFn {
+        Self {
             create_wayland_surface_khr: unsafe {
                 unsafe extern "system" fn create_wayland_surface_khr(
                     _instance: Instance,
@@ -1379,38 +1023,15 @@ impl KhrWaylandSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateWaylandSurfaceKHR.html>"]
-    pub unsafe fn create_wayland_surface_khr(
-        &self,
-        instance: Instance,
-        p_create_info: *const WaylandSurfaceCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_wayland_surface_khr)(instance, p_create_info, p_allocator, p_surface)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html>"]
-    pub unsafe fn get_physical_device_wayland_presentation_support_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        queue_family_index: u32,
-        display: *mut wl_display,
-    ) -> Bool32 {
-        (self.get_physical_device_wayland_presentation_support_khr)(
-            physical_device,
-            queue_family_index,
-            display,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_wayland_surface'"]
 impl StructureType {
     pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_006_000);
 }
 impl KhrMirSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_mir_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_mir_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 4u32;
 }
@@ -1423,13 +1044,13 @@ impl KhrMirSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrMirSurfaceFn {}
+        Self {}
     }
 }
 impl KhrAndroidSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_android_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_android_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 6u32;
 }
@@ -1451,7 +1072,7 @@ impl KhrAndroidSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrAndroidSurfaceFn {
+        Self {
             create_android_surface_khr: unsafe {
                 unsafe extern "system" fn create_android_surface_khr(
                     _instance: Instance,
@@ -1475,25 +1096,15 @@ impl KhrAndroidSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateAndroidSurfaceKHR.html>"]
-    pub unsafe fn create_android_surface_khr(
-        &self,
-        instance: Instance,
-        p_create_info: *const AndroidSurfaceCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_android_surface_khr)(instance, p_create_info, p_allocator, p_surface)
-    }
 }
 #[doc = "Generated from 'VK_KHR_android_surface'"]
 impl StructureType {
     pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_008_000);
 }
 impl KhrWin32SurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_win32_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 6u32;
 }
@@ -1520,7 +1131,7 @@ impl KhrWin32SurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrWin32SurfaceFn {
+        Self {
             create_win32_surface_khr: unsafe {
                 unsafe extern "system" fn create_win32_surface_khr(
                     _instance: Instance,
@@ -1564,36 +1175,15 @@ impl KhrWin32SurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateWin32SurfaceKHR.html>"]
-    pub unsafe fn create_win32_surface_khr(
-        &self,
-        instance: Instance,
-        p_create_info: *const Win32SurfaceCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_win32_surface_khr)(instance, p_create_info, p_allocator, p_surface)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html>"]
-    pub unsafe fn get_physical_device_win32_presentation_support_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        queue_family_index: u32,
-    ) -> Bool32 {
-        (self.get_physical_device_win32_presentation_support_khr)(
-            physical_device,
-            queue_family_index,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_win32_surface'"]
 impl StructureType {
     pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_009_000);
 }
 impl AndroidNativeBufferFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_ANDROID_native_buffer\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_native_buffer\0") }
     }
     pub const SPEC_VERSION: u32 = 8u32;
 }
@@ -1643,7 +1233,7 @@ impl AndroidNativeBufferFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AndroidNativeBufferFn {
+        Self {
             get_swapchain_gralloc_usage_android: unsafe {
                 unsafe extern "system" fn get_swapchain_gralloc_usage_android(
                     _device: Device,
@@ -1737,80 +1327,17 @@ impl AndroidNativeBufferFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSwapchainGrallocUsageANDROID.html>"]
-    pub unsafe fn get_swapchain_gralloc_usage_android(
-        &self,
-        device: Device,
-        format: Format,
-        image_usage: ImageUsageFlags,
-        gralloc_usage: *mut c_int,
-    ) -> Result {
-        (self.get_swapchain_gralloc_usage_android)(device, format, image_usage, gralloc_usage)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireImageANDROID.html>"]
-    pub unsafe fn acquire_image_android(
-        &self,
-        device: Device,
-        image: Image,
-        native_fence_fd: c_int,
-        semaphore: Semaphore,
-        fence: Fence,
-    ) -> Result {
-        (self.acquire_image_android)(device, image, native_fence_fd, semaphore, fence)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueSignalReleaseImageANDROID.html>"]
-    pub unsafe fn queue_signal_release_image_android(
-        &self,
-        queue: Queue,
-        wait_semaphore_count: u32,
-        p_wait_semaphores: *const Semaphore,
-        image: Image,
-        p_native_fence_fd: *mut c_int,
-    ) -> Result {
-        (self.queue_signal_release_image_android)(
-            queue,
-            wait_semaphore_count,
-            p_wait_semaphores,
-            image,
-            p_native_fence_fd,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSwapchainGrallocUsage2ANDROID.html>"]
-    pub unsafe fn get_swapchain_gralloc_usage2_android(
-        &self,
-        device: Device,
-        format: Format,
-        image_usage: ImageUsageFlags,
-        swapchain_image_usage: SwapchainImageUsageFlagsANDROID,
-        gralloc_consumer_usage: *mut u64,
-        gralloc_producer_usage: *mut u64,
-    ) -> Result {
-        (self.get_swapchain_gralloc_usage2_android)(
-            device,
-            format,
-            image_usage,
-            swapchain_image_usage,
-            gralloc_consumer_usage,
-            gralloc_producer_usage,
-        )
-    }
 }
 #[doc = "Generated from 'VK_ANDROID_native_buffer'"]
 impl StructureType {
     pub const NATIVE_BUFFER_ANDROID: Self = Self(1_000_010_000);
-}
-#[doc = "Generated from 'VK_ANDROID_native_buffer'"]
-impl StructureType {
     pub const SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID: Self = Self(1_000_010_001);
-}
-#[doc = "Generated from 'VK_ANDROID_native_buffer'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID: Self = Self(1_000_010_002);
 }
 impl ExtDebugReportFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_debug_report\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_report\0") }
     }
     pub const SPEC_VERSION: u32 = 10u32;
 }
@@ -1851,7 +1378,7 @@ impl ExtDebugReportFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDebugReportFn {
+        Self {
             create_debug_report_callback_ext: unsafe {
                 unsafe extern "system" fn create_debug_report_callback_ext(
                     _instance: Instance,
@@ -1922,77 +1449,28 @@ impl ExtDebugReportFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDebugReportCallbackEXT.html>"]
-    pub unsafe fn create_debug_report_callback_ext(
-        &self,
-        instance: Instance,
-        p_create_info: *const DebugReportCallbackCreateInfoEXT,
-        p_allocator: *const AllocationCallbacks,
-        p_callback: *mut DebugReportCallbackEXT,
-    ) -> Result {
-        (self.create_debug_report_callback_ext)(instance, p_create_info, p_allocator, p_callback)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDebugReportCallbackEXT.html>"]
-    pub unsafe fn destroy_debug_report_callback_ext(
-        &self,
-        instance: Instance,
-        callback: DebugReportCallbackEXT,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_debug_report_callback_ext)(instance, callback, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDebugReportMessageEXT.html>"]
-    pub unsafe fn debug_report_message_ext(
-        &self,
-        instance: Instance,
-        flags: DebugReportFlagsEXT,
-        object_type: DebugReportObjectTypeEXT,
-        object: u64,
-        location: usize,
-        message_code: i32,
-        p_layer_prefix: *const c_char,
-        p_message: *const c_char,
-    ) {
-        (self.debug_report_message_ext)(
-            instance,
-            flags,
-            object_type,
-            object,
-            location,
-            message_code,
-            p_layer_prefix,
-            p_message,
-        )
-    }
-}
-#[doc = "Generated from 'VK_EXT_debug_report'"]
-impl StructureType {
-    pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = Self(1_000_011_000);
-}
-#[doc = "Generated from 'VK_EXT_debug_report'"]
-impl StructureType {
-    pub const DEBUG_REPORT_CREATE_INFO_EXT: Self = Self::DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
 }
 #[doc = "Generated from 'VK_EXT_debug_report'"]
-impl Result {
-    pub const ERROR_VALIDATION_FAILED_EXT: Self = Self(-1000011001);
+impl DebugReportObjectTypeEXT {
+    pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000);
+    pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000);
 }
 #[doc = "Generated from 'VK_EXT_debug_report'"]
 impl ObjectType {
     pub const DEBUG_REPORT_CALLBACK_EXT: Self = Self(1_000_011_000);
 }
 #[doc = "Generated from 'VK_EXT_debug_report'"]
-impl DebugReportObjectTypeEXT {
-    pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000);
+impl Result {
+    pub const ERROR_VALIDATION_FAILED_EXT: Self = Self(-1_000_011_001);
 }
 #[doc = "Generated from 'VK_EXT_debug_report'"]
-impl DebugReportObjectTypeEXT {
-    pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000);
+impl StructureType {
+    pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = Self(1_000_011_000);
 }
 impl NvGlslShaderFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_glsl_shader\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_glsl_shader\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -2005,17 +1483,19 @@ impl NvGlslShaderFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvGlslShaderFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_glsl_shader'"]
 impl Result {
-    pub const ERROR_INVALID_SHADER_NV: Self = Self(-1000012000);
+    pub const ERROR_INVALID_SHADER_NV: Self = Self(-1_000_012_000);
 }
 impl ExtDepthRangeUnrestrictedFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_depth_range_unrestricted\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_range_unrestricted\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -2028,13 +1508,17 @@ impl ExtDepthRangeUnrestrictedFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDepthRangeUnrestrictedFn {}
+        Self {}
     }
 }
 impl KhrSamplerMirrorClampToEdgeFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_sampler_mirror_clamp_to_edge\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_sampler_mirror_clamp_to_edge\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -2047,21 +1531,20 @@ impl KhrSamplerMirrorClampToEdgeFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSamplerMirrorClampToEdgeFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_sampler_mirror_clamp_to_edge'"]
 impl SamplerAddressMode {
+    #[doc = "Note that this defines what was previously a core enum, and so uses the 'value' attribute rather than 'offset', and does not have a suffix. This is a special case, and should not be repeated"]
     pub const MIRROR_CLAMP_TO_EDGE: Self = Self(4);
-}
-#[doc = "Generated from 'VK_KHR_sampler_mirror_clamp_to_edge'"]
-impl SamplerAddressMode {
+    #[deprecated = "Introduced for consistency with extension suffixing rules"]
     pub const MIRROR_CLAMP_TO_EDGE_KHR: Self = Self::MIRROR_CLAMP_TO_EDGE;
 }
 impl ImgFilterCubicFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_IMG_filter_cubic\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_filter_cubic\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -2074,21 +1557,22 @@ impl ImgFilterCubicFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ImgFilterCubicFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_IMG_filter_cubic'"]
 impl Filter {
-    pub const CUBIC_IMG: Self = Self(1_000_015_000);
+    pub const CUBIC_IMG: Self = Self::CUBIC_EXT;
 }
 #[doc = "Generated from 'VK_IMG_filter_cubic'"]
 impl FormatFeatureFlags {
-    pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = Self(0b10_0000_0000_0000);
+    #[doc = "Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled"]
+    pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC_EXT;
 }
 impl AmdExtension17Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_17\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_17\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -2101,13 +1585,13 @@ impl AmdExtension17Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension17Fn {}
+        Self {}
     }
 }
 impl AmdExtension18Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_18\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_18\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -2120,13 +1604,13 @@ impl AmdExtension18Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension18Fn {}
+        Self {}
     }
 }
 impl AmdRasterizationOrderFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_rasterization_order\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_rasterization_order\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -2139,7 +1623,7 @@ impl AmdRasterizationOrderFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdRasterizationOrderFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_AMD_rasterization_order'"]
@@ -2147,9 +1631,9 @@ impl StructureType {
     pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = Self(1_000_018_000);
 }
 impl AmdExtension20Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_20\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_20\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -2162,13 +1646,15 @@ impl AmdExtension20Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension20Fn {}
+        Self {}
     }
 }
 impl AmdShaderTrinaryMinmaxFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_trinary_minmax\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_trinary_minmax\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -2181,13 +1667,17 @@ impl AmdShaderTrinaryMinmaxFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdShaderTrinaryMinmaxFn {}
+        Self {}
     }
 }
 impl AmdShaderExplicitVertexParameterFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_explicit_vertex_parameter\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_AMD_shader_explicit_vertex_parameter\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -2200,13 +1690,13 @@ impl AmdShaderExplicitVertexParameterFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdShaderExplicitVertexParameterFn {}
+        Self {}
     }
 }
 impl ExtDebugMarkerFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_debug_marker\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_marker\0") }
     }
     pub const SPEC_VERSION: u32 = 4u32;
 }
@@ -2247,7 +1737,7 @@ impl ExtDebugMarkerFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDebugMarkerFn {
+        Self {
             debug_marker_set_object_tag_ext: unsafe {
                 unsafe extern "system" fn debug_marker_set_object_tag_ext(
                     _device: Device,
@@ -2344,66 +1834,24 @@ impl ExtDebugMarkerFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDebugMarkerSetObjectTagEXT.html>"]
-    pub unsafe fn debug_marker_set_object_tag_ext(
-        &self,
-        device: Device,
-        p_tag_info: *const DebugMarkerObjectTagInfoEXT,
-    ) -> Result {
-        (self.debug_marker_set_object_tag_ext)(device, p_tag_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDebugMarkerSetObjectNameEXT.html>"]
-    pub unsafe fn debug_marker_set_object_name_ext(
-        &self,
-        device: Device,
-        p_name_info: *const DebugMarkerObjectNameInfoEXT,
-    ) -> Result {
-        (self.debug_marker_set_object_name_ext)(device, p_name_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDebugMarkerBeginEXT.html>"]
-    pub unsafe fn cmd_debug_marker_begin_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        p_marker_info: *const DebugMarkerMarkerInfoEXT,
-    ) {
-        (self.cmd_debug_marker_begin_ext)(command_buffer, p_marker_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDebugMarkerEndEXT.html>"]
-    pub unsafe fn cmd_debug_marker_end_ext(&self, command_buffer: CommandBuffer) {
-        (self.cmd_debug_marker_end_ext)(command_buffer)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDebugMarkerInsertEXT.html>"]
-    pub unsafe fn cmd_debug_marker_insert_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        p_marker_info: *const DebugMarkerMarkerInfoEXT,
-    ) {
-        (self.cmd_debug_marker_insert_ext)(command_buffer, p_marker_info)
-    }
 }
 #[doc = "Generated from 'VK_EXT_debug_marker'"]
 impl StructureType {
     pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = Self(1_000_022_000);
-}
-#[doc = "Generated from 'VK_EXT_debug_marker'"]
-impl StructureType {
     pub const DEBUG_MARKER_OBJECT_TAG_INFO_EXT: Self = Self(1_000_022_001);
-}
-#[doc = "Generated from 'VK_EXT_debug_marker'"]
-impl StructureType {
     pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = Self(1_000_022_002);
 }
 impl KhrVideoQueueFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_video_queue\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_queue\0") }
     }
-    pub const SPEC_VERSION: u32 = 2u32;
+    pub const SPEC_VERSION: u32 = 8u32;
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn(
     physical_device: PhysicalDevice,
-    p_video_profile: *const VideoProfileKHR,
+    p_video_profile: *const VideoProfileInfoKHR,
     p_capabilities: *mut VideoCapabilitiesKHR,
 ) -> Result;
 #[allow(non_camel_case_types)]
@@ -2430,15 +1878,15 @@ pub type PFN_vkDestroyVideoSessionKHR = unsafe extern "system" fn(
 pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn(
     device: Device,
     video_session: VideoSessionKHR,
-    p_video_session_memory_requirements_count: *mut u32,
-    p_video_session_memory_requirements: *mut VideoGetMemoryPropertiesKHR,
+    p_memory_requirements_count: *mut u32,
+    p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR,
 ) -> Result;
 #[allow(non_camel_case_types)]
 pub type PFN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn(
     device: Device,
     video_session: VideoSessionKHR,
-    video_session_bind_memory_count: u32,
-    p_video_session_bind_memories: *const VideoBindMemoryKHR,
+    bind_session_memory_info_count: u32,
+    p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR,
 ) -> Result;
 #[allow(non_camel_case_types)]
 pub type PFN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn(
@@ -2497,11 +1945,11 @@ impl KhrVideoQueueFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrVideoQueueFn {
+        Self {
             get_physical_device_video_capabilities_khr: unsafe {
                 unsafe extern "system" fn get_physical_device_video_capabilities_khr(
                     _physical_device: PhysicalDevice,
-                    _p_video_profile: *const VideoProfileKHR,
+                    _p_video_profile: *const VideoProfileInfoKHR,
                     _p_capabilities: *mut VideoCapabilitiesKHR,
                 ) -> Result {
                     panic!(concat!(
@@ -2586,8 +2034,8 @@ impl KhrVideoQueueFn {
                 unsafe extern "system" fn get_video_session_memory_requirements_khr(
                     _device: Device,
                     _video_session: VideoSessionKHR,
-                    _p_video_session_memory_requirements_count: *mut u32,
-                    _p_video_session_memory_requirements: *mut VideoGetMemoryPropertiesKHR,
+                    _p_memory_requirements_count: *mut u32,
+                    _p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR,
                 ) -> Result {
                     panic!(concat!(
                         "Unable to load ",
@@ -2608,8 +2056,8 @@ impl KhrVideoQueueFn {
                 unsafe extern "system" fn bind_video_session_memory_khr(
                     _device: Device,
                     _video_session: VideoSessionKHR,
-                    _video_session_bind_memory_count: u32,
-                    _p_video_session_bind_memories: *const VideoBindMemoryKHR,
+                    _bind_session_memory_info_count: u32,
+                    _p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR,
                 ) -> Result {
                     panic!(concat!(
                         "Unable to load ",
@@ -2750,232 +2198,62 @@ impl KhrVideoQueueFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html>"]
-    pub unsafe fn get_physical_device_video_capabilities_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_video_profile: *const VideoProfileKHR,
-        p_capabilities: *mut VideoCapabilitiesKHR,
-    ) -> Result {
-        (self.get_physical_device_video_capabilities_khr)(
-            physical_device,
-            p_video_profile,
-            p_capabilities,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html>"]
-    pub unsafe fn get_physical_device_video_format_properties_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR,
-        p_video_format_property_count: *mut u32,
-        p_video_format_properties: *mut VideoFormatPropertiesKHR,
-    ) -> Result {
-        (self.get_physical_device_video_format_properties_khr)(
-            physical_device,
-            p_video_format_info,
-            p_video_format_property_count,
-            p_video_format_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateVideoSessionKHR.html>"]
-    pub unsafe fn create_video_session_khr(
-        &self,
-        device: Device,
-        p_create_info: *const VideoSessionCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_video_session: *mut VideoSessionKHR,
-    ) -> Result {
-        (self.create_video_session_khr)(device, p_create_info, p_allocator, p_video_session)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyVideoSessionKHR.html>"]
-    pub unsafe fn destroy_video_session_khr(
-        &self,
-        device: Device,
-        video_session: VideoSessionKHR,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_video_session_khr)(device, video_session, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetVideoSessionMemoryRequirementsKHR.html>"]
-    pub unsafe fn get_video_session_memory_requirements_khr(
-        &self,
-        device: Device,
-        video_session: VideoSessionKHR,
-        p_video_session_memory_requirements_count: *mut u32,
-        p_video_session_memory_requirements: *mut VideoGetMemoryPropertiesKHR,
-    ) -> Result {
-        (self.get_video_session_memory_requirements_khr)(
-            device,
-            video_session,
-            p_video_session_memory_requirements_count,
-            p_video_session_memory_requirements,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindVideoSessionMemoryKHR.html>"]
-    pub unsafe fn bind_video_session_memory_khr(
-        &self,
-        device: Device,
-        video_session: VideoSessionKHR,
-        video_session_bind_memory_count: u32,
-        p_video_session_bind_memories: *const VideoBindMemoryKHR,
-    ) -> Result {
-        (self.bind_video_session_memory_khr)(
-            device,
-            video_session,
-            video_session_bind_memory_count,
-            p_video_session_bind_memories,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateVideoSessionParametersKHR.html>"]
-    pub unsafe fn create_video_session_parameters_khr(
-        &self,
-        device: Device,
-        p_create_info: *const VideoSessionParametersCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_video_session_parameters: *mut VideoSessionParametersKHR,
-    ) -> Result {
-        (self.create_video_session_parameters_khr)(
-            device,
-            p_create_info,
-            p_allocator,
-            p_video_session_parameters,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateVideoSessionParametersKHR.html>"]
-    pub unsafe fn update_video_session_parameters_khr(
-        &self,
-        device: Device,
-        video_session_parameters: VideoSessionParametersKHR,
-        p_update_info: *const VideoSessionParametersUpdateInfoKHR,
-    ) -> Result {
-        (self.update_video_session_parameters_khr)(device, video_session_parameters, p_update_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyVideoSessionParametersKHR.html>"]
-    pub unsafe fn destroy_video_session_parameters_khr(
-        &self,
-        device: Device,
-        video_session_parameters: VideoSessionParametersKHR,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_video_session_parameters_khr)(device, video_session_parameters, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginVideoCodingKHR.html>"]
-    pub unsafe fn cmd_begin_video_coding_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_begin_info: *const VideoBeginCodingInfoKHR,
-    ) {
-        (self.cmd_begin_video_coding_khr)(command_buffer, p_begin_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndVideoCodingKHR.html>"]
-    pub unsafe fn cmd_end_video_coding_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_end_coding_info: *const VideoEndCodingInfoKHR,
-    ) {
-        (self.cmd_end_video_coding_khr)(command_buffer, p_end_coding_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdControlVideoCodingKHR.html>"]
-    pub unsafe fn cmd_control_video_coding_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_coding_control_info: *const VideoCodingControlInfoKHR,
-    ) {
-        (self.cmd_control_video_coding_khr)(command_buffer, p_coding_control_info)
-    }
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
-    pub const VIDEO_PROFILE_KHR: Self = Self(1_000_023_000);
 }
 #[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
-    pub const VIDEO_CAPABILITIES_KHR: Self = Self(1_000_023_001);
+impl ObjectType {
+    #[doc = "VkVideoSessionKHR"]
+    pub const VIDEO_SESSION_KHR: Self = Self(1_000_023_000);
+    #[doc = "VkVideoSessionParametersKHR"]
+    pub const VIDEO_SESSION_PARAMETERS_KHR: Self = Self(1_000_023_001);
 }
 #[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
-    pub const VIDEO_PICTURE_RESOURCE_KHR: Self = Self(1_000_023_002);
+impl QueryResultFlags {
+    pub const WITH_STATUS_KHR: Self = Self(0b1_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
-    pub const VIDEO_GET_MEMORY_PROPERTIES_KHR: Self = Self(1_000_023_003);
+impl QueryType {
+    pub const RESULT_STATUS_ONLY_KHR: Self = Self(1_000_023_000);
 }
 #[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
-    pub const VIDEO_BIND_MEMORY_KHR: Self = Self(1_000_023_004);
+impl Result {
+    pub const ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_000);
+    pub const ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_001);
+    pub const ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_002);
+    pub const ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_003);
+    pub const ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_004);
+    pub const ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_005);
 }
 #[doc = "Generated from 'VK_KHR_video_queue'"]
 impl StructureType {
+    pub const VIDEO_PROFILE_INFO_KHR: Self = Self(1_000_023_000);
+    pub const VIDEO_CAPABILITIES_KHR: Self = Self(1_000_023_001);
+    pub const VIDEO_PICTURE_RESOURCE_INFO_KHR: Self = Self(1_000_023_002);
+    pub const VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: Self = Self(1_000_023_003);
+    pub const BIND_VIDEO_SESSION_MEMORY_INFO_KHR: Self = Self(1_000_023_004);
     pub const VIDEO_SESSION_CREATE_INFO_KHR: Self = Self(1_000_023_005);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
     pub const VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_023_006);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
     pub const VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: Self = Self(1_000_023_007);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
     pub const VIDEO_BEGIN_CODING_INFO_KHR: Self = Self(1_000_023_008);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
     pub const VIDEO_END_CODING_INFO_KHR: Self = Self(1_000_023_009);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
     pub const VIDEO_CODING_CONTROL_INFO_KHR: Self = Self(1_000_023_010);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
-    pub const VIDEO_REFERENCE_SLOT_KHR: Self = Self(1_000_023_011);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
-    pub const VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: Self = Self(1_000_023_012);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
-    pub const VIDEO_PROFILES_KHR: Self = Self(1_000_023_013);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
+    pub const VIDEO_REFERENCE_SLOT_INFO_KHR: Self = Self(1_000_023_011);
+    pub const QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: Self = Self(1_000_023_012);
+    pub const VIDEO_PROFILE_LIST_INFO_KHR: Self = Self(1_000_023_013);
     pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: Self = Self(1_000_023_014);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl StructureType {
     pub const VIDEO_FORMAT_PROPERTIES_KHR: Self = Self(1_000_023_015);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl ObjectType {
-    pub const VIDEO_SESSION_KHR: Self = Self(1_000_023_000);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl ObjectType {
-    pub const VIDEO_SESSION_PARAMETERS_KHR: Self = Self(1_000_023_001);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl QueryType {
-    pub const RESULT_STATUS_ONLY_KHR: Self = Self(1_000_023_000);
-}
-#[doc = "Generated from 'VK_KHR_video_queue'"]
-impl QueryResultFlags {
-    pub const WITH_STATUS_KHR: Self = Self(0b1_0000);
+    pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: Self = Self(1_000_023_016);
 }
 impl KhrVideoDecodeQueueFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_video_decode_queue\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_queue\0") }
     }
-    pub const SPEC_VERSION: u32 = 1u32;
+    pub const SPEC_VERSION: u32 = 7u32;
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    p_frame_info: *const VideoDecodeInfoKHR,
+    p_decode_info: *const VideoDecodeInfoKHR,
 );
 #[derive(Clone)]
 pub struct KhrVideoDecodeQueueFn {
@@ -2988,11 +2266,11 @@ impl KhrVideoDecodeQueueFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrVideoDecodeQueueFn {
+        Self {
             cmd_decode_video_khr: unsafe {
                 unsafe extern "system" fn cmd_decode_video_khr(
                     _command_buffer: CommandBuffer,
-                    _p_frame_info: *const VideoDecodeInfoKHR,
+                    _p_decode_info: *const VideoDecodeInfoKHR,
                 ) {
                     panic!(concat!("Unable to load ", stringify!(cmd_decode_video_khr)))
                 }
@@ -3007,79 +2285,57 @@ impl KhrVideoDecodeQueueFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDecodeVideoKHR.html>"]
-    pub unsafe fn cmd_decode_video_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_frame_info: *const VideoDecodeInfoKHR,
-    ) {
-        (self.cmd_decode_video_khr)(command_buffer, p_frame_info)
-    }
-}
-#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl StructureType {
-    pub const VIDEO_DECODE_INFO_KHR: Self = Self(1_000_024_000);
 }
 #[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl QueueFlags {
-    pub const VIDEO_DECODE_KHR: Self = Self(0b10_0000);
-}
-#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl PipelineStageFlags2KHR {
-    pub const VIDEO_DECODE: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl AccessFlags2KHR {
-    pub const VIDEO_DECODE_READ: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl AccessFlags2KHR {
-    pub const VIDEO_DECODE_WRITE: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+impl AccessFlags2 {
+    pub const VIDEO_DECODE_READ_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const VIDEO_DECODE_WRITE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_decode_queue'"]
 impl BufferUsageFlags {
     pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b10_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl BufferUsageFlags {
     pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl ImageUsageFlags {
-    pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl ImageUsageFlags {
-    pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b1000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl ImageUsageFlags {
-    pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b1_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
 impl FormatFeatureFlags {
     pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
+    pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl FormatFeatureFlags {
+impl FormatFeatureFlags2 {
+    pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
     pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_decode_queue'"]
 impl ImageLayout {
     pub const VIDEO_DECODE_DST_KHR: Self = Self(1_000_024_000);
+    pub const VIDEO_DECODE_SRC_KHR: Self = Self(1_000_024_001);
+    pub const VIDEO_DECODE_DPB_KHR: Self = Self(1_000_024_002);
 }
 #[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl ImageLayout {
-    pub const VIDEO_DECODE_SRC_KHR: Self = Self(1_000_024_001);
+impl ImageUsageFlags {
+    pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000);
+    pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b1000_0000_0000);
+    pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b1_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_decode_queue'"]
-impl ImageLayout {
-    pub const VIDEO_DECODE_DPB_KHR: Self = Self(1_000_024_002);
+impl PipelineStageFlags2 {
+    pub const VIDEO_DECODE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
+impl QueueFlags {
+    pub const VIDEO_DECODE_KHR: Self = Self(0b10_0000);
+}
+#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
+impl StructureType {
+    pub const VIDEO_DECODE_INFO_KHR: Self = Self(1_000_024_000);
+    pub const VIDEO_DECODE_CAPABILITIES_KHR: Self = Self(1_000_024_001);
+    pub const VIDEO_DECODE_USAGE_INFO_KHR: Self = Self(1_000_024_002);
 }
 impl AmdGcnShaderFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_gcn_shader\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gcn_shader\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -3092,13 +2348,13 @@ impl AmdGcnShaderFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdGcnShaderFn {}
+        Self {}
     }
 }
 impl NvDedicatedAllocationFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_dedicated_allocation\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_dedicated_allocation\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -3111,25 +2367,19 @@ impl NvDedicatedAllocationFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvDedicatedAllocationFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_dedicated_allocation'"]
 impl StructureType {
     pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = Self(1_000_026_000);
-}
-#[doc = "Generated from 'VK_NV_dedicated_allocation'"]
-impl StructureType {
     pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: Self = Self(1_000_026_001);
-}
-#[doc = "Generated from 'VK_NV_dedicated_allocation'"]
-impl StructureType {
     pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_026_002);
 }
 impl ExtExtension28Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_28\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_28\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -3142,13 +2392,13 @@ impl ExtExtension28Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension28Fn {}
+        Self {}
     }
 }
 impl ExtTransformFeedbackFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_transform_feedback\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_transform_feedback\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -3218,7 +2468,7 @@ impl ExtTransformFeedbackFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtTransformFeedbackFn {
+        Self {
             cmd_bind_transform_feedback_buffers_ext: unsafe {
                 unsafe extern "system" fn cmd_bind_transform_feedback_buffers_ext(
                     _command_buffer: CommandBuffer,
@@ -3359,147 +2609,37 @@ impl ExtTransformFeedbackFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindTransformFeedbackBuffersEXT.html>"]
-    pub unsafe fn cmd_bind_transform_feedback_buffers_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        first_binding: u32,
-        binding_count: u32,
-        p_buffers: *const Buffer,
-        p_offsets: *const DeviceSize,
-        p_sizes: *const DeviceSize,
-    ) {
-        (self.cmd_bind_transform_feedback_buffers_ext)(
-            command_buffer,
-            first_binding,
-            binding_count,
-            p_buffers,
-            p_offsets,
-            p_sizes,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginTransformFeedbackEXT.html>"]
-    pub unsafe fn cmd_begin_transform_feedback_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        first_counter_buffer: u32,
-        counter_buffer_count: u32,
-        p_counter_buffers: *const Buffer,
-        p_counter_buffer_offsets: *const DeviceSize,
-    ) {
-        (self.cmd_begin_transform_feedback_ext)(
-            command_buffer,
-            first_counter_buffer,
-            counter_buffer_count,
-            p_counter_buffers,
-            p_counter_buffer_offsets,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndTransformFeedbackEXT.html>"]
-    pub unsafe fn cmd_end_transform_feedback_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        first_counter_buffer: u32,
-        counter_buffer_count: u32,
-        p_counter_buffers: *const Buffer,
-        p_counter_buffer_offsets: *const DeviceSize,
-    ) {
-        (self.cmd_end_transform_feedback_ext)(
-            command_buffer,
-            first_counter_buffer,
-            counter_buffer_count,
-            p_counter_buffers,
-            p_counter_buffer_offsets,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginQueryIndexedEXT.html>"]
-    pub unsafe fn cmd_begin_query_indexed_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        query_pool: QueryPool,
-        query: u32,
-        flags: QueryControlFlags,
-        index: u32,
-    ) {
-        (self.cmd_begin_query_indexed_ext)(command_buffer, query_pool, query, flags, index)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndQueryIndexedEXT.html>"]
-    pub unsafe fn cmd_end_query_indexed_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        query_pool: QueryPool,
-        query: u32,
-        index: u32,
-    ) {
-        (self.cmd_end_query_indexed_ext)(command_buffer, query_pool, query, index)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirectByteCountEXT.html>"]
-    pub unsafe fn cmd_draw_indirect_byte_count_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        instance_count: u32,
-        first_instance: u32,
-        counter_buffer: Buffer,
-        counter_buffer_offset: DeviceSize,
-        counter_offset: u32,
-        vertex_stride: u32,
-    ) {
-        (self.cmd_draw_indirect_byte_count_ext)(
-            command_buffer,
-            instance_count,
-            first_instance,
-            counter_buffer,
-            counter_buffer_offset,
-            counter_offset,
-            vertex_stride,
-        )
-    }
-}
-#[doc = "Generated from 'VK_EXT_transform_feedback'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: Self = Self(1_000_028_000);
 }
 #[doc = "Generated from 'VK_EXT_transform_feedback'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: Self = Self(1_000_028_001);
-}
-#[doc = "Generated from 'VK_EXT_transform_feedback'"]
-impl StructureType {
-    pub const PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: Self = Self(1_000_028_002);
-}
-#[doc = "Generated from 'VK_EXT_transform_feedback'"]
-impl QueryType {
-    pub const TRANSFORM_FEEDBACK_STREAM_EXT: Self = Self(1_000_028_004);
+impl AccessFlags {
+    pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
+    pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
+    pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self =
+        Self(0b1000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_transform_feedback'"]
 impl BufferUsageFlags {
     pub const TRANSFORM_FEEDBACK_BUFFER_EXT: Self = Self(0b1000_0000_0000);
-}
-#[doc = "Generated from 'VK_EXT_transform_feedback'"]
-impl BufferUsageFlags {
     pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT: Self = Self(0b1_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_transform_feedback'"]
-impl AccessFlags {
-    pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_EXT_transform_feedback'"]
-impl AccessFlags {
-    pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
+impl PipelineStageFlags {
+    pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_transform_feedback'"]
-impl AccessFlags {
-    pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self =
-        Self(0b1000_0000_0000_0000_0000_0000_0000);
+impl QueryType {
+    pub const TRANSFORM_FEEDBACK_STREAM_EXT: Self = Self(1_000_028_004);
 }
 #[doc = "Generated from 'VK_EXT_transform_feedback'"]
-impl PipelineStageFlags {
-    pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: Self = Self(1_000_028_000);
+    pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: Self = Self(1_000_028_001);
+    pub const PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: Self = Self(1_000_028_002);
 }
 impl NvxBinaryImportFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_binary_import\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_binary_import\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -3547,7 +2687,7 @@ impl NvxBinaryImportFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvxBinaryImportFn {
+        Self {
             create_cu_module_nvx: unsafe {
                 unsafe extern "system" fn create_cu_module_nvx(
                     _device: Device,
@@ -3648,85 +2788,27 @@ impl NvxBinaryImportFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateCuModuleNVX.html>"]
-    pub unsafe fn create_cu_module_nvx(
-        &self,
-        device: Device,
-        p_create_info: *const CuModuleCreateInfoNVX,
-        p_allocator: *const AllocationCallbacks,
-        p_module: *mut CuModuleNVX,
-    ) -> Result {
-        (self.create_cu_module_nvx)(device, p_create_info, p_allocator, p_module)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateCuFunctionNVX.html>"]
-    pub unsafe fn create_cu_function_nvx(
-        &self,
-        device: Device,
-        p_create_info: *const CuFunctionCreateInfoNVX,
-        p_allocator: *const AllocationCallbacks,
-        p_function: *mut CuFunctionNVX,
-    ) -> Result {
-        (self.create_cu_function_nvx)(device, p_create_info, p_allocator, p_function)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyCuModuleNVX.html>"]
-    pub unsafe fn destroy_cu_module_nvx(
-        &self,
-        device: Device,
-        module: CuModuleNVX,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_cu_module_nvx)(device, module, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyCuFunctionNVX.html>"]
-    pub unsafe fn destroy_cu_function_nvx(
-        &self,
-        device: Device,
-        function: CuFunctionNVX,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_cu_function_nvx)(device, function, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCuLaunchKernelNVX.html>"]
-    pub unsafe fn cmd_cu_launch_kernel_nvx(
-        &self,
-        command_buffer: CommandBuffer,
-        p_launch_info: *const CuLaunchInfoNVX,
-    ) {
-        (self.cmd_cu_launch_kernel_nvx)(command_buffer, p_launch_info)
-    }
 }
 #[doc = "Generated from 'VK_NVX_binary_import'"]
-impl StructureType {
-    pub const CU_MODULE_CREATE_INFO_NVX: Self = Self(1_000_029_000);
-}
-#[doc = "Generated from 'VK_NVX_binary_import'"]
-impl StructureType {
-    pub const CU_FUNCTION_CREATE_INFO_NVX: Self = Self(1_000_029_001);
-}
-#[doc = "Generated from 'VK_NVX_binary_import'"]
-impl StructureType {
-    pub const CU_LAUNCH_INFO_NVX: Self = Self(1_000_029_002);
-}
-#[doc = "Generated from 'VK_NVX_binary_import'"]
-impl ObjectType {
+impl DebugReportObjectTypeEXT {
     pub const CU_MODULE_NVX: Self = Self(1_000_029_000);
-}
-#[doc = "Generated from 'VK_NVX_binary_import'"]
-impl ObjectType {
     pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001);
 }
 #[doc = "Generated from 'VK_NVX_binary_import'"]
-impl DebugReportObjectTypeEXT {
+impl ObjectType {
     pub const CU_MODULE_NVX: Self = Self(1_000_029_000);
+    pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001);
 }
 #[doc = "Generated from 'VK_NVX_binary_import'"]
-impl DebugReportObjectTypeEXT {
-    pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001);
+impl StructureType {
+    pub const CU_MODULE_CREATE_INFO_NVX: Self = Self(1_000_029_000);
+    pub const CU_FUNCTION_CREATE_INFO_NVX: Self = Self(1_000_029_001);
+    pub const CU_LAUNCH_INFO_NVX: Self = Self(1_000_029_002);
 }
 impl NvxImageViewHandleFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_image_view_handle\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_image_view_handle\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -3751,7 +2833,7 @@ impl NvxImageViewHandleFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvxImageViewHandleFn {
+        Self {
             get_image_view_handle_nvx: unsafe {
                 unsafe extern "system" fn get_image_view_handle_nvx(
                     _device: Device,
@@ -3793,36 +2875,16 @@ impl NvxImageViewHandleFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageViewHandleNVX.html>"]
-    pub unsafe fn get_image_view_handle_nvx(
-        &self,
-        device: Device,
-        p_info: *const ImageViewHandleInfoNVX,
-    ) -> u32 {
-        (self.get_image_view_handle_nvx)(device, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageViewAddressNVX.html>"]
-    pub unsafe fn get_image_view_address_nvx(
-        &self,
-        device: Device,
-        image_view: ImageView,
-        p_properties: *mut ImageViewAddressPropertiesNVX,
-    ) -> Result {
-        (self.get_image_view_address_nvx)(device, image_view, p_properties)
-    }
 }
 #[doc = "Generated from 'VK_NVX_image_view_handle'"]
 impl StructureType {
     pub const IMAGE_VIEW_HANDLE_INFO_NVX: Self = Self(1_000_030_000);
-}
-#[doc = "Generated from 'VK_NVX_image_view_handle'"]
-impl StructureType {
     pub const IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: Self = Self(1_000_030_001);
 }
 impl AmdExtension32Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_32\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_32\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -3835,13 +2897,13 @@ impl AmdExtension32Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension32Fn {}
+        Self {}
     }
 }
 impl AmdExtension33Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_33\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_33\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -3854,13 +2916,13 @@ impl AmdExtension33Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension33Fn {}
+        Self {}
     }
 }
 impl AmdDrawIndirectCountFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_draw_indirect_count\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_draw_indirect_count\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -3896,7 +2958,7 @@ impl AmdDrawIndirectCountFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdDrawIndirectCountFn {
+        Self {
             cmd_draw_indirect_count_amd: unsafe {
                 unsafe extern "system" fn cmd_draw_indirect_count_amd(
                     _command_buffer: CommandBuffer,
@@ -3948,53 +3010,11 @@ impl AmdDrawIndirectCountFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirectCountAMD.html>"]
-    pub unsafe fn cmd_draw_indirect_count_amd(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        count_buffer: Buffer,
-        count_buffer_offset: DeviceSize,
-        max_draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_indirect_count_amd)(
-            command_buffer,
-            buffer,
-            offset,
-            count_buffer,
-            count_buffer_offset,
-            max_draw_count,
-            stride,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirectCountAMD.html>"]
-    pub unsafe fn cmd_draw_indexed_indirect_count_amd(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        count_buffer: Buffer,
-        count_buffer_offset: DeviceSize,
-        max_draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_indexed_indirect_count_amd)(
-            command_buffer,
-            buffer,
-            offset,
-            count_buffer,
-            count_buffer_offset,
-            max_draw_count,
-            stride,
-        )
-    }
 }
 impl AmdExtension35Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_35\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_35\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -4007,13 +3027,15 @@ impl AmdExtension35Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension35Fn {}
+        Self {}
     }
 }
 impl AmdNegativeViewportHeightFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_negative_viewport_height\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_negative_viewport_height\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4026,13 +3048,15 @@ impl AmdNegativeViewportHeightFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdNegativeViewportHeightFn {}
+        Self {}
     }
 }
 impl AmdGpuShaderHalfFloatFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_gpu_shader_half_float\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_half_float\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -4045,13 +3069,13 @@ impl AmdGpuShaderHalfFloatFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdGpuShaderHalfFloatFn {}
+        Self {}
     }
 }
 impl AmdShaderBallotFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_ballot\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_ballot\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4064,15 +3088,15 @@ impl AmdShaderBallotFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdShaderBallotFn {}
+        Self {}
     }
 }
 impl ExtVideoEncodeH264Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_encode_h264\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") }
     }
-    pub const SPEC_VERSION: u32 = 2u32;
+    pub const SPEC_VERSION: u32 = 10u32;
 }
 #[derive(Clone)]
 pub struct ExtVideoEncodeH264Fn {}
@@ -4083,55 +3107,31 @@ impl ExtVideoEncodeH264Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtVideoEncodeH264Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_video_encode_h264'"]
 impl StructureType {
     pub const VIDEO_ENCODE_H264_CAPABILITIES_EXT: Self = Self(1_000_038_000);
-}
-#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: Self = Self(1_000_038_001);
-}
-#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_002);
-}
-#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_003);
-}
-#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_004);
-}
-#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_005);
-}
-#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_H264_NALU_SLICE_EXT: Self = Self(1_000_038_006);
-}
-#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: Self = Self(1_000_038_007);
-}
-#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_H264_PROFILE_EXT: Self = Self(1_000_038_008);
+    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_001);
+    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_002);
+    pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_003);
+    pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_004);
+    pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: Self = Self(1_000_038_005);
+    pub const VIDEO_ENCODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_038_007);
+    pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_008);
+    pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_009);
 }
 #[doc = "Generated from 'VK_EXT_video_encode_h264'"]
 impl VideoCodecOperationFlagsKHR {
     pub const ENCODE_H264_EXT: Self = Self(0b1_0000_0000_0000_0000);
 }
 impl ExtVideoEncodeH265Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_encode_h265\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h265\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 10u32;
 }
 #[derive(Clone)]
 pub struct ExtVideoEncodeH265Fn {}
@@ -4142,68 +3142,63 @@ impl ExtVideoEncodeH265Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtVideoEncodeH265Fn {}
+        Self {}
     }
 }
-impl ExtVideoDecodeH264Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_decode_h264\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_EXT_video_encode_h265'"]
+impl StructureType {
+    pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000);
+    pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_001);
+    pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_002);
+    pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_003);
+    pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_004);
+    pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: Self = Self(1_000_039_005);
+    pub const VIDEO_ENCODE_H265_PROFILE_INFO_EXT: Self = Self(1_000_039_007);
+    pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_009);
+    pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_010);
+}
+#[doc = "Generated from 'VK_EXT_video_encode_h265'"]
+impl VideoCodecOperationFlagsKHR {
+    pub const ENCODE_H265_EXT: Self = Self(0b10_0000_0000_0000_0000);
+}
+impl KhrVideoDecodeH264Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h264\0") }
     }
-    pub const SPEC_VERSION: u32 = 3u32;
+    pub const SPEC_VERSION: u32 = 8u32;
 }
 #[derive(Clone)]
-pub struct ExtVideoDecodeH264Fn {}
-unsafe impl Send for ExtVideoDecodeH264Fn {}
-unsafe impl Sync for ExtVideoDecodeH264Fn {}
-impl ExtVideoDecodeH264Fn {
+pub struct KhrVideoDecodeH264Fn {}
+unsafe impl Send for KhrVideoDecodeH264Fn {}
+unsafe impl Sync for KhrVideoDecodeH264Fn {}
+impl KhrVideoDecodeH264Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtVideoDecodeH264Fn {}
+        Self {}
     }
 }
-#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H264_CAPABILITIES_EXT: Self = Self(1_000_040_000);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: Self = Self(1_000_040_001);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H264_PICTURE_INFO_EXT: Self = Self(1_000_040_002);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H264_MVC_EXT: Self = Self(1_000_040_003);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H264_PROFILE_EXT: Self = Self(1_000_040_004);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_040_005);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_040_006);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
+#[doc = "Generated from 'VK_KHR_video_decode_h264'"]
 impl StructureType {
-    pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_040_007);
+    pub const VIDEO_DECODE_H264_CAPABILITIES_KHR: Self = Self(1_000_040_000);
+    pub const VIDEO_DECODE_H264_PICTURE_INFO_KHR: Self = Self(1_000_040_001);
+    pub const VIDEO_DECODE_H264_PROFILE_INFO_KHR: Self = Self(1_000_040_003);
+    pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_040_004);
+    pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_040_005);
+    pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: Self = Self(1_000_040_006);
 }
-#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
+#[doc = "Generated from 'VK_KHR_video_decode_h264'"]
 impl VideoCodecOperationFlagsKHR {
-    pub const DECODE_H264_EXT: Self = Self(0b1);
+    pub const DECODE_H264: Self = Self(0b1);
 }
 impl AmdTextureGatherBiasLodFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_texture_gather_bias_lod\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_texture_gather_bias_lod\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4216,7 +3211,7 @@ impl AmdTextureGatherBiasLodFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdTextureGatherBiasLodFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_AMD_texture_gather_bias_lod'"]
@@ -4224,9 +3219,9 @@ impl StructureType {
     pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = Self(1_000_041_000);
 }
 impl AmdShaderInfoFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_info\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_info\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4250,7 +3245,7 @@ impl AmdShaderInfoFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdShaderInfoFn {
+        Self {
             get_shader_info_amd: unsafe {
                 unsafe extern "system" fn get_shader_info_amd(
                     _device: Device,
@@ -4273,30 +3268,11 @@ impl AmdShaderInfoFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetShaderInfoAMD.html>"]
-    pub unsafe fn get_shader_info_amd(
-        &self,
-        device: Device,
-        pipeline: Pipeline,
-        shader_stage: ShaderStageFlags,
-        info_type: ShaderInfoTypeAMD,
-        p_info_size: *mut usize,
-        p_info: *mut c_void,
-    ) -> Result {
-        (self.get_shader_info_amd)(
-            device,
-            pipeline,
-            shader_stage,
-            info_type,
-            p_info_size,
-            p_info,
-        )
-    }
 }
 impl AmdExtension44Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_44\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_44\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -4309,40 +3285,104 @@ impl AmdExtension44Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension44Fn {}
+        Self {}
     }
 }
-impl AmdExtension45Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_45\0")
-            .expect("Wrong extension string")
+impl KhrDynamicRenderingFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dynamic_rendering\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBeginRendering = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    p_rendering_info: *const RenderingInfo,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdEndRendering = unsafe extern "system" fn(command_buffer: CommandBuffer);
 #[derive(Clone)]
-pub struct AmdExtension45Fn {}
-unsafe impl Send for AmdExtension45Fn {}
-unsafe impl Sync for AmdExtension45Fn {}
-impl AmdExtension45Fn {
+pub struct KhrDynamicRenderingFn {
+    pub cmd_begin_rendering_khr: PFN_vkCmdBeginRendering,
+    pub cmd_end_rendering_khr: PFN_vkCmdEndRendering,
+}
+unsafe impl Send for KhrDynamicRenderingFn {}
+unsafe impl Sync for KhrDynamicRenderingFn {}
+impl KhrDynamicRenderingFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension45Fn {}
+        Self {
+            cmd_begin_rendering_khr: unsafe {
+                unsafe extern "system" fn cmd_begin_rendering_khr(
+                    _command_buffer: CommandBuffer,
+                    _p_rendering_info: *const RenderingInfo,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_begin_rendering_khr)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderingKHR\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_begin_rendering_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_end_rendering_khr: unsafe {
+                unsafe extern "system" fn cmd_end_rendering_khr(_command_buffer: CommandBuffer) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_end_rendering_khr)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderingKHR\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_end_rendering_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
-#[doc = "Generated from 'VK_AMD_extension_45'"]
-impl PipelineCreateFlags {
-    pub const RESERVED_21_AMD: Self = Self(0b10_0000_0000_0000_0000_0000);
+#[doc = "Generated from 'VK_KHR_dynamic_rendering'"]
+impl AttachmentStoreOp {
+    pub const NONE_KHR: Self = Self::NONE;
 }
-#[doc = "Generated from 'VK_AMD_extension_45'"]
+#[doc = "Generated from 'VK_KHR_dynamic_rendering'"]
 impl PipelineCreateFlags {
-    pub const RESERVED_22_AMD: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
+        Self(0b10_0000_0000_0000_0000_0000);
+    pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self =
+        Self(0b100_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_KHR_dynamic_rendering'"]
+impl StructureType {
+    pub const RENDERING_INFO_KHR: Self = Self::RENDERING_INFO;
+    pub const RENDERING_ATTACHMENT_INFO_KHR: Self = Self::RENDERING_ATTACHMENT_INFO;
+    pub const PIPELINE_RENDERING_CREATE_INFO_KHR: Self = Self::PIPELINE_RENDERING_CREATE_INFO;
+    pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
+    pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: Self =
+        Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
+    pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_044_006);
+    pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: Self = Self(1_000_044_007);
+    pub const ATTACHMENT_SAMPLE_COUNT_INFO_AMD: Self = Self(1_000_044_008);
+    pub const ATTACHMENT_SAMPLE_COUNT_INFO_NV: Self = Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
+    pub const MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: Self = Self(1_000_044_009);
 }
 impl AmdExtension46Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_46\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_46\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -4355,13 +3395,15 @@ impl AmdExtension46Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension46Fn {}
+        Self {}
     }
 }
 impl AmdShaderImageLoadStoreLodFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_image_load_store_lod\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_image_load_store_lod\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4374,13 +3416,13 @@ impl AmdShaderImageLoadStoreLodFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdShaderImageLoadStoreLodFn {}
+        Self {}
     }
 }
 impl NvxExtension48Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_extension_48\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_extension_48\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -4393,13 +3435,13 @@ impl NvxExtension48Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvxExtension48Fn {}
+        Self {}
     }
 }
 impl GoogleExtension49Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_49\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_49\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -4412,13 +3454,15 @@ impl GoogleExtension49Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GoogleExtension49Fn {}
+        Self {}
     }
 }
 impl GgpStreamDescriptorSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_stream_descriptor_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_stream_descriptor_surface\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4440,7 +3484,7 @@ impl GgpStreamDescriptorSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GgpStreamDescriptorSurfaceFn {
+        Self {
             create_stream_descriptor_surface_ggp: unsafe {
                 unsafe extern "system" fn create_stream_descriptor_surface_ggp(
                     _instance: Instance,
@@ -4465,25 +3509,15 @@ impl GgpStreamDescriptorSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateStreamDescriptorSurfaceGGP.html>"]
-    pub unsafe fn create_stream_descriptor_surface_ggp(
-        &self,
-        instance: Instance,
-        p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_stream_descriptor_surface_ggp)(instance, p_create_info, p_allocator, p_surface)
-    }
 }
 #[doc = "Generated from 'VK_GGP_stream_descriptor_surface'"]
 impl StructureType {
     pub const STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: Self = Self(1_000_049_000);
 }
 impl NvCornerSampledImageFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_corner_sampled_image\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_corner_sampled_image\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -4496,7 +3530,7 @@ impl NvCornerSampledImageFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvCornerSampledImageFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_corner_sampled_image'"]
@@ -4507,37 +3541,10 @@ impl ImageCreateFlags {
 impl StructureType {
     pub const PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: Self = Self(1_000_050_000);
 }
-impl NvExtension52Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_52\0")
-            .expect("Wrong extension string")
-    }
-    pub const SPEC_VERSION: u32 = 0u32;
-}
-#[derive(Clone)]
-pub struct NvExtension52Fn {}
-unsafe impl Send for NvExtension52Fn {}
-unsafe impl Sync for NvExtension52Fn {}
-impl NvExtension52Fn {
-    pub fn load<F>(mut _f: F) -> Self
-    where
-        F: FnMut(&::std::ffi::CStr) -> *const c_void,
-    {
-        NvExtension52Fn {}
-    }
-}
-#[doc = "Generated from 'VK_NV_extension_52'"]
-impl ShaderModuleCreateFlags {
-    pub const RESERVED_0_NV: Self = Self(0b1);
-}
-#[doc = "Generated from 'VK_NV_extension_52'"]
-impl PipelineShaderStageCreateFlags {
-    pub const RESERVED_2_NV: Self = Self(0b100);
-}
 impl NvExtension53Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_53\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_53\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -4550,13 +3557,13 @@ impl NvExtension53Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension53Fn {}
+        Self {}
     }
 }
 impl KhrMultiviewFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_multiview\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_multiview\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4569,31 +3576,25 @@ impl KhrMultiviewFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrMultiviewFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_multiview'"]
-impl StructureType {
-    pub const RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: Self = Self::RENDER_PASS_MULTIVIEW_CREATE_INFO;
+impl DependencyFlags {
+    pub const VIEW_LOCAL_KHR: Self = Self::VIEW_LOCAL;
 }
 #[doc = "Generated from 'VK_KHR_multiview'"]
 impl StructureType {
+    pub const RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: Self = Self::RENDER_PASS_MULTIVIEW_CREATE_INFO;
     pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: Self =
         Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
-}
-#[doc = "Generated from 'VK_KHR_multiview'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: Self =
         Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
 }
-#[doc = "Generated from 'VK_KHR_multiview'"]
-impl DependencyFlags {
-    pub const VIEW_LOCAL_KHR: Self = Self::VIEW_LOCAL;
-}
 impl ImgFormatPvrtcFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_IMG_format_pvrtc\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_format_pvrtc\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4606,45 +3607,26 @@ impl ImgFormatPvrtcFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ImgFormatPvrtcFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_IMG_format_pvrtc'"]
 impl Format {
     pub const PVRTC1_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_000);
-}
-#[doc = "Generated from 'VK_IMG_format_pvrtc'"]
-impl Format {
     pub const PVRTC1_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_001);
-}
-#[doc = "Generated from 'VK_IMG_format_pvrtc'"]
-impl Format {
     pub const PVRTC2_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_002);
-}
-#[doc = "Generated from 'VK_IMG_format_pvrtc'"]
-impl Format {
     pub const PVRTC2_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_003);
-}
-#[doc = "Generated from 'VK_IMG_format_pvrtc'"]
-impl Format {
     pub const PVRTC1_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_004);
-}
-#[doc = "Generated from 'VK_IMG_format_pvrtc'"]
-impl Format {
     pub const PVRTC1_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_005);
-}
-#[doc = "Generated from 'VK_IMG_format_pvrtc'"]
-impl Format {
     pub const PVRTC2_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_006);
-}
-#[doc = "Generated from 'VK_IMG_format_pvrtc'"]
-impl Format {
     pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_007);
 }
 impl NvExternalMemoryCapabilitiesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_external_memory_capabilities\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_capabilities\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4672,7 +3654,7 @@ impl NvExternalMemoryCapabilitiesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExternalMemoryCapabilitiesFn {
+        Self {
             get_physical_device_external_image_format_properties_nv: unsafe {
                 unsafe extern "system" fn get_physical_device_external_image_format_properties_nv(
                     _physical_device: PhysicalDevice,
@@ -4701,34 +3683,11 @@ impl NvExternalMemoryCapabilitiesFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html>"]
-    pub unsafe fn get_physical_device_external_image_format_properties_nv(
-        &self,
-        physical_device: PhysicalDevice,
-        format: Format,
-        ty: ImageType,
-        tiling: ImageTiling,
-        usage: ImageUsageFlags,
-        flags: ImageCreateFlags,
-        external_handle_type: ExternalMemoryHandleTypeFlagsNV,
-        p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV,
-    ) -> Result {
-        (self.get_physical_device_external_image_format_properties_nv)(
-            physical_device,
-            format,
-            ty,
-            tiling,
-            usage,
-            flags,
-            external_handle_type,
-            p_external_image_format_properties,
-        )
-    }
 }
 impl NvExternalMemoryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_external_memory\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4741,21 +3700,18 @@ impl NvExternalMemoryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExternalMemoryFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_external_memory'"]
 impl StructureType {
     pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = Self(1_000_056_000);
-}
-#[doc = "Generated from 'VK_NV_external_memory'"]
-impl StructureType {
     pub const EXPORT_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_056_001);
 }
 impl NvExternalMemoryWin32Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_external_memory_win32\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_win32\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -4777,7 +3733,7 @@ impl NvExternalMemoryWin32Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExternalMemoryWin32Fn {
+        Self {
             get_memory_win32_handle_nv: unsafe {
                 unsafe extern "system" fn get_memory_win32_handle_nv(
                     _device: Device,
@@ -4801,29 +3757,16 @@ impl NvExternalMemoryWin32Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryWin32HandleNV.html>"]
-    pub unsafe fn get_memory_win32_handle_nv(
-        &self,
-        device: Device,
-        memory: DeviceMemory,
-        handle_type: ExternalMemoryHandleTypeFlagsNV,
-        p_handle: *mut HANDLE,
-    ) -> Result {
-        (self.get_memory_win32_handle_nv)(device, memory, handle_type, p_handle)
-    }
 }
 #[doc = "Generated from 'VK_NV_external_memory_win32'"]
 impl StructureType {
     pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_000);
-}
-#[doc = "Generated from 'VK_NV_external_memory_win32'"]
-impl StructureType {
     pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_001);
 }
 impl NvWin32KeyedMutexFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_win32_keyed_mutex\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_win32_keyed_mutex\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -4836,7 +3779,7 @@ impl NvWin32KeyedMutexFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvWin32KeyedMutexFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_win32_keyed_mutex'"]
@@ -4844,9 +3787,13 @@ impl StructureType {
     pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = Self(1_000_058_000);
 }
 impl KhrGetPhysicalDeviceProperties2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_get_physical_device_properties2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_get_physical_device_properties2\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -4910,7 +3857,7 @@ impl KhrGetPhysicalDeviceProperties2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrGetPhysicalDeviceProperties2Fn {
+        Self {
             get_physical_device_features2_khr: unsafe {
                 unsafe extern "system" fn get_physical_device_features2_khr(
                     _physical_device: PhysicalDevice,
@@ -5058,128 +4005,26 @@ impl KhrGetPhysicalDeviceProperties2Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures2KHR.html>"]
-    pub unsafe fn get_physical_device_features2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_features: *mut PhysicalDeviceFeatures2,
-    ) {
-        (self.get_physical_device_features2_khr)(physical_device, p_features)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties2KHR.html>"]
-    pub unsafe fn get_physical_device_properties2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_properties: *mut PhysicalDeviceProperties2,
-    ) {
-        (self.get_physical_device_properties2_khr)(physical_device, p_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html>"]
-    pub unsafe fn get_physical_device_format_properties2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        format: Format,
-        p_format_properties: *mut FormatProperties2,
-    ) {
-        (self.get_physical_device_format_properties2_khr)(
-            physical_device,
-            format,
-            p_format_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html>"]
-    pub unsafe fn get_physical_device_image_format_properties2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
-        p_image_format_properties: *mut ImageFormatProperties2,
-    ) -> Result {
-        (self.get_physical_device_image_format_properties2_khr)(
-            physical_device,
-            p_image_format_info,
-            p_image_format_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html>"]
-    pub unsafe fn get_physical_device_queue_family_properties2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_queue_family_property_count: *mut u32,
-        p_queue_family_properties: *mut QueueFamilyProperties2,
-    ) {
-        (self.get_physical_device_queue_family_properties2_khr)(
-            physical_device,
-            p_queue_family_property_count,
-            p_queue_family_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html>"]
-    pub unsafe fn get_physical_device_memory_properties2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
-    ) {
-        (self.get_physical_device_memory_properties2_khr)(physical_device, p_memory_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html>"]
-    pub unsafe fn get_physical_device_sparse_image_format_properties2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
-        p_property_count: *mut u32,
-        p_properties: *mut SparseImageFormatProperties2,
-    ) {
-        (self.get_physical_device_sparse_image_format_properties2_khr)(
-            physical_device,
-            p_format_info,
-            p_property_count,
-            p_properties,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_FEATURES_2_KHR: Self = Self::PHYSICAL_DEVICE_FEATURES_2;
-}
-#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_PROPERTIES_2_KHR: Self = Self::PHYSICAL_DEVICE_PROPERTIES_2;
-}
-#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
-impl StructureType {
     pub const FORMAT_PROPERTIES_2_KHR: Self = Self::FORMAT_PROPERTIES_2;
-}
-#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
-impl StructureType {
     pub const IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::IMAGE_FORMAT_PROPERTIES_2;
-}
-#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: Self =
         Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
-}
-#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
-impl StructureType {
     pub const QUEUE_FAMILY_PROPERTIES_2_KHR: Self = Self::QUEUE_FAMILY_PROPERTIES_2;
-}
-#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: Self =
         Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
-}
-#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
-impl StructureType {
     pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2;
-}
-#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: Self =
         Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
 }
 impl KhrDeviceGroupFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_device_group\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group\0") }
     }
     pub const SPEC_VERSION: u32 = 4u32;
 }
@@ -5224,7 +4069,7 @@ impl KhrDeviceGroupFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDeviceGroupFn {
+        Self {
             get_device_group_peer_memory_features_khr: unsafe {
                 unsafe extern "system" fn get_device_group_peer_memory_features_khr(
                     _device: Device,
@@ -5376,161 +4221,48 @@ impl KhrDeviceGroupFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html>"]
-    pub unsafe fn get_device_group_peer_memory_features_khr(
-        &self,
-        device: Device,
-        heap_index: u32,
-        local_device_index: u32,
-        remote_device_index: u32,
-        p_peer_memory_features: *mut PeerMemoryFeatureFlags,
-    ) {
-        (self.get_device_group_peer_memory_features_khr)(
-            device,
-            heap_index,
-            local_device_index,
-            remote_device_index,
-            p_peer_memory_features,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDeviceMaskKHR.html>"]
-    pub unsafe fn cmd_set_device_mask_khr(&self, command_buffer: CommandBuffer, device_mask: u32) {
-        (self.cmd_set_device_mask_khr)(command_buffer, device_mask)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatchBaseKHR.html>"]
-    pub unsafe fn cmd_dispatch_base_khr(
-        &self,
-        command_buffer: 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,
-    ) {
-        (self.cmd_dispatch_base_khr)(
-            command_buffer,
-            base_group_x,
-            base_group_y,
-            base_group_z,
-            group_count_x,
-            group_count_y,
-            group_count_z,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html>"]
-    pub unsafe fn get_device_group_present_capabilities_khr(
-        &self,
-        device: Device,
-        p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR,
-    ) -> Result {
-        (self.get_device_group_present_capabilities_khr)(
-            device,
-            p_device_group_present_capabilities,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html>"]
-    pub unsafe fn get_device_group_surface_present_modes_khr(
-        &self,
-        device: Device,
-        surface: SurfaceKHR,
-        p_modes: *mut DeviceGroupPresentModeFlagsKHR,
-    ) -> Result {
-        (self.get_device_group_surface_present_modes_khr)(device, surface, p_modes)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html>"]
-    pub unsafe fn get_physical_device_present_rectangles_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        surface: SurfaceKHR,
-        p_rect_count: *mut u32,
-        p_rects: *mut Rect2D,
-    ) -> Result {
-        (self.get_physical_device_present_rectangles_khr)(
-            physical_device,
-            surface,
-            p_rect_count,
-            p_rects,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireNextImage2KHR.html>"]
-    pub unsafe fn acquire_next_image2_khr(
-        &self,
-        device: Device,
-        p_acquire_info: *const AcquireNextImageInfoKHR,
-        p_image_index: *mut u32,
-    ) -> Result {
-        (self.acquire_next_image2_khr)(device, p_acquire_info, p_image_index)
-    }
-}
-#[doc = "Generated from 'VK_KHR_device_group'"]
-impl StructureType {
-    pub const MEMORY_ALLOCATE_FLAGS_INFO_KHR: Self = Self::MEMORY_ALLOCATE_FLAGS_INFO;
 }
 #[doc = "Generated from 'VK_KHR_device_group'"]
-impl StructureType {
-    pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: Self =
-        Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
-}
-#[doc = "Generated from 'VK_KHR_device_group'"]
-impl StructureType {
-    pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: Self =
-        Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
+impl DependencyFlags {
+    pub const DEVICE_GROUP_KHR: Self = Self::DEVICE_GROUP;
 }
 #[doc = "Generated from 'VK_KHR_device_group'"]
-impl StructureType {
-    pub const DEVICE_GROUP_SUBMIT_INFO_KHR: Self = Self::DEVICE_GROUP_SUBMIT_INFO;
+impl ImageCreateFlags {
+    pub const SPLIT_INSTANCE_BIND_REGIONS_KHR: Self = Self::SPLIT_INSTANCE_BIND_REGIONS;
 }
 #[doc = "Generated from 'VK_KHR_device_group'"]
-impl StructureType {
-    pub const DEVICE_GROUP_BIND_SPARSE_INFO_KHR: Self = Self::DEVICE_GROUP_BIND_SPARSE_INFO;
+impl MemoryAllocateFlags {
+    pub const DEVICE_MASK_KHR: Self = Self::DEVICE_MASK;
 }
 #[doc = "Generated from 'VK_KHR_device_group'"]
 impl PeerMemoryFeatureFlags {
     pub const COPY_SRC_KHR: Self = Self::COPY_SRC;
-}
-#[doc = "Generated from 'VK_KHR_device_group'"]
-impl PeerMemoryFeatureFlags {
     pub const COPY_DST_KHR: Self = Self::COPY_DST;
-}
-#[doc = "Generated from 'VK_KHR_device_group'"]
-impl PeerMemoryFeatureFlags {
     pub const GENERIC_SRC_KHR: Self = Self::GENERIC_SRC;
-}
-#[doc = "Generated from 'VK_KHR_device_group'"]
-impl PeerMemoryFeatureFlags {
     pub const GENERIC_DST_KHR: Self = Self::GENERIC_DST;
 }
 #[doc = "Generated from 'VK_KHR_device_group'"]
-impl MemoryAllocateFlags {
-    pub const DEVICE_MASK_KHR: Self = Self::DEVICE_MASK;
-}
-#[doc = "Generated from 'VK_KHR_device_group'"]
 impl PipelineCreateFlags {
     pub const VIEW_INDEX_FROM_DEVICE_INDEX_KHR: Self = Self::VIEW_INDEX_FROM_DEVICE_INDEX;
 }
 #[doc = "Generated from 'VK_KHR_device_group'"]
-impl DependencyFlags {
-    pub const DEVICE_GROUP_KHR: Self = Self::DEVICE_GROUP;
-}
-#[doc = "Generated from 'VK_KHR_device_group'"]
 impl StructureType {
+    pub const MEMORY_ALLOCATE_FLAGS_INFO_KHR: Self = Self::MEMORY_ALLOCATE_FLAGS_INFO;
+    pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: Self =
+        Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
+    pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: Self =
+        Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
+    pub const DEVICE_GROUP_SUBMIT_INFO_KHR: Self = Self::DEVICE_GROUP_SUBMIT_INFO;
+    pub const DEVICE_GROUP_BIND_SPARSE_INFO_KHR: Self = Self::DEVICE_GROUP_BIND_SPARSE_INFO;
     pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: Self =
         Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
-}
-#[doc = "Generated from 'VK_KHR_device_group'"]
-impl StructureType {
     pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: Self =
         Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
 }
-#[doc = "Generated from 'VK_KHR_device_group'"]
-impl ImageCreateFlags {
-    pub const SPLIT_INSTANCE_BIND_REGIONS_KHR: Self = Self::SPLIT_INSTANCE_BIND_REGIONS;
-}
 impl ExtValidationFlagsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_validation_flags\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_flags\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -5543,7 +4275,7 @@ impl ExtValidationFlagsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtValidationFlagsFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_validation_flags'"]
@@ -5551,9 +4283,9 @@ impl StructureType {
     pub const VALIDATION_FLAGS_EXT: Self = Self(1_000_061_000);
 }
 impl NnViSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NN_vi_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NN_vi_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -5575,7 +4307,7 @@ impl NnViSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NnViSurfaceFn {
+        Self {
             create_vi_surface_nn: unsafe {
                 unsafe extern "system" fn create_vi_surface_nn(
                     _instance: Instance,
@@ -5596,25 +4328,17 @@ impl NnViSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateViSurfaceNN.html>"]
-    pub unsafe fn create_vi_surface_nn(
-        &self,
-        instance: Instance,
-        p_create_info: *const ViSurfaceCreateInfoNN,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_vi_surface_nn)(instance, p_create_info, p_allocator, p_surface)
-    }
 }
 #[doc = "Generated from 'VK_NN_vi_surface'"]
 impl StructureType {
     pub const VI_SURFACE_CREATE_INFO_NN: Self = Self(1_000_062_000);
 }
 impl KhrShaderDrawParametersFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_draw_parameters\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_draw_parameters\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -5627,13 +4351,15 @@ impl KhrShaderDrawParametersFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderDrawParametersFn {}
+        Self {}
     }
 }
 impl ExtShaderSubgroupBallotFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_subgroup_ballot\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_ballot\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -5646,13 +4372,13 @@ impl ExtShaderSubgroupBallotFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtShaderSubgroupBallotFn {}
+        Self {}
     }
 }
 impl ExtShaderSubgroupVoteFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_subgroup_vote\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_vote\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -5665,13 +4391,17 @@ impl ExtShaderSubgroupVoteFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtShaderSubgroupVoteFn {}
+        Self {}
     }
 }
 impl ExtTextureCompressionAstcHdrFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_texture_compression_astc_hdr\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_texture_compression_astc_hdr\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -5684,73 +4414,35 @@ impl ExtTextureCompressionAstcHdrFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtTextureCompressionAstcHdrFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: Self = Self(1_000_066_000);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_000);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_5X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_001);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
 impl Format {
-    pub const ASTC_5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_002);
+    pub const ASTC_4X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_4X4_SFLOAT_BLOCK;
+    pub const ASTC_5X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X4_SFLOAT_BLOCK;
+    pub const ASTC_5X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X5_SFLOAT_BLOCK;
+    pub const ASTC_6X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X5_SFLOAT_BLOCK;
+    pub const ASTC_6X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X6_SFLOAT_BLOCK;
+    pub const ASTC_8X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X5_SFLOAT_BLOCK;
+    pub const ASTC_8X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X6_SFLOAT_BLOCK;
+    pub const ASTC_8X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X8_SFLOAT_BLOCK;
+    pub const ASTC_10X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X5_SFLOAT_BLOCK;
+    pub const ASTC_10X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X6_SFLOAT_BLOCK;
+    pub const ASTC_10X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X8_SFLOAT_BLOCK;
+    pub const ASTC_10X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X10_SFLOAT_BLOCK;
+    pub const ASTC_12X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X10_SFLOAT_BLOCK;
+    pub const ASTC_12X12_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X12_SFLOAT_BLOCK;
 }
 #[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_6X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_003);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_6X6_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_004);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_8X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_005);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_8X6_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_006);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_8X8_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_007);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_10X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_008);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_10X6_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_009);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_10X8_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_010);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_10X10_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_011);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_12X10_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_012);
-}
-#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
-impl Format {
-    pub const ASTC_12X12_SFLOAT_BLOCK_EXT: Self = Self(1_000_066_013);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: Self =
+        Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
 }
 impl ExtAstcDecodeModeFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_astc_decode_mode\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_astc_decode_mode\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -5763,40 +4455,43 @@ impl ExtAstcDecodeModeFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtAstcDecodeModeFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_astc_decode_mode'"]
 impl StructureType {
     pub const IMAGE_VIEW_ASTC_DECODE_MODE_EXT: Self = Self(1_000_067_000);
-}
-#[doc = "Generated from 'VK_EXT_astc_decode_mode'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: Self = Self(1_000_067_001);
 }
-impl ImgExtension69Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_IMG_extension_69\0")
-            .expect("Wrong extension string")
+impl ExtPipelineRobustnessFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_robustness\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ImgExtension69Fn {}
-unsafe impl Send for ImgExtension69Fn {}
-unsafe impl Sync for ImgExtension69Fn {}
-impl ImgExtension69Fn {
+pub struct ExtPipelineRobustnessFn {}
+unsafe impl Send for ExtPipelineRobustnessFn {}
+unsafe impl Sync for ExtPipelineRobustnessFn {}
+impl ExtPipelineRobustnessFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ImgExtension69Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_EXT_pipeline_robustness'"]
+impl StructureType {
+    pub const PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: Self = Self(1_000_068_000);
+    pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: Self = Self(1_000_068_001);
+    pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: Self = Self(1_000_068_002);
+}
 impl KhrMaintenance1Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_maintenance1\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance1\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -5817,7 +4512,7 @@ impl KhrMaintenance1Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrMaintenance1Fn {
+        Self {
             trim_command_pool_khr: unsafe {
                 unsafe extern "system" fn trim_command_pool_khr(
                     _device: Device,
@@ -5840,36 +4535,26 @@ impl KhrMaintenance1Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkTrimCommandPoolKHR.html>"]
-    pub unsafe fn trim_command_pool_khr(
-        &self,
-        device: Device,
-        command_pool: CommandPool,
-        flags: CommandPoolTrimFlags,
-    ) {
-        (self.trim_command_pool_khr)(device, command_pool, flags)
-    }
-}
-#[doc = "Generated from 'VK_KHR_maintenance1'"]
-impl Result {
-    pub const ERROR_OUT_OF_POOL_MEMORY_KHR: Self = Self::ERROR_OUT_OF_POOL_MEMORY;
 }
 #[doc = "Generated from 'VK_KHR_maintenance1'"]
 impl FormatFeatureFlags {
     pub const TRANSFER_SRC_KHR: Self = Self::TRANSFER_SRC;
-}
-#[doc = "Generated from 'VK_KHR_maintenance1'"]
-impl FormatFeatureFlags {
     pub const TRANSFER_DST_KHR: Self = Self::TRANSFER_DST;
 }
 #[doc = "Generated from 'VK_KHR_maintenance1'"]
 impl ImageCreateFlags {
     pub const TYPE_2D_ARRAY_COMPATIBLE_KHR: Self = Self::TYPE_2D_ARRAY_COMPATIBLE;
 }
+#[doc = "Generated from 'VK_KHR_maintenance1'"]
+impl Result {
+    pub const ERROR_OUT_OF_POOL_MEMORY_KHR: Self = Self::ERROR_OUT_OF_POOL_MEMORY;
+}
 impl KhrDeviceGroupCreationFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_device_group_creation\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group_creation\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -5890,7 +4575,7 @@ impl KhrDeviceGroupCreationFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDeviceGroupCreationFn {
+        Self {
             enumerate_physical_device_groups_khr: unsafe {
                 unsafe extern "system" fn enumerate_physical_device_groups_khr(
                     _instance: Instance,
@@ -5914,36 +4599,24 @@ impl KhrDeviceGroupCreationFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html>"]
-    pub unsafe fn enumerate_physical_device_groups_khr(
-        &self,
-        instance: Instance,
-        p_physical_device_group_count: *mut u32,
-        p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
-    ) -> Result {
-        (self.enumerate_physical_device_groups_khr)(
-            instance,
-            p_physical_device_group_count,
-            p_physical_device_group_properties,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_device_group_creation'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_GROUP_PROPERTIES;
+impl MemoryHeapFlags {
+    pub const MULTI_INSTANCE_KHR: Self = Self::MULTI_INSTANCE;
 }
 #[doc = "Generated from 'VK_KHR_device_group_creation'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_GROUP_PROPERTIES;
     pub const DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: Self = Self::DEVICE_GROUP_DEVICE_CREATE_INFO;
 }
-#[doc = "Generated from 'VK_KHR_device_group_creation'"]
-impl MemoryHeapFlags {
-    pub const MULTI_INSTANCE_KHR: Self = Self::MULTI_INSTANCE;
-}
 impl KhrExternalMemoryCapabilitiesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_memory_capabilities\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_external_memory_capabilities\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -5965,7 +4638,7 @@ impl KhrExternalMemoryCapabilitiesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalMemoryCapabilitiesFn {
+        Self {
             get_physical_device_external_buffer_properties_khr: unsafe {
                 unsafe extern "system" fn get_physical_device_external_buffer_properties_khr(
                     _physical_device: PhysicalDevice,
@@ -5989,86 +4662,37 @@ impl KhrExternalMemoryCapabilitiesFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html>"]
-    pub unsafe fn get_physical_device_external_buffer_properties_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
-        p_external_buffer_properties: *mut ExternalBufferProperties,
-    ) {
-        (self.get_physical_device_external_buffer_properties_khr)(
-            physical_device,
-            p_external_buffer_info,
-            p_external_buffer_properties,
-        )
-    }
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: Self =
-        Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl StructureType {
-    pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: Self = Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: Self =
-        Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl StructureType {
-    pub const EXTERNAL_BUFFER_PROPERTIES_KHR: Self = Self::EXTERNAL_BUFFER_PROPERTIES;
 }
 #[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_ID_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_ID_PROPERTIES;
+impl ExternalMemoryFeatureFlags {
+    pub const DEDICATED_ONLY_KHR: Self = Self::DEDICATED_ONLY;
+    pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
+    pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
 }
 #[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
 impl ExternalMemoryHandleTypeFlags {
     pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl ExternalMemoryHandleTypeFlags {
     pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl ExternalMemoryHandleTypeFlags {
     pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl ExternalMemoryHandleTypeFlags {
     pub const D3D11_TEXTURE_KHR: Self = Self::D3D11_TEXTURE;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl ExternalMemoryHandleTypeFlags {
     pub const D3D11_TEXTURE_KMT_KHR: Self = Self::D3D11_TEXTURE_KMT;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl ExternalMemoryHandleTypeFlags {
     pub const D3D12_HEAP_KHR: Self = Self::D3D12_HEAP;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl ExternalMemoryHandleTypeFlags {
     pub const D3D12_RESOURCE_KHR: Self = Self::D3D12_RESOURCE;
 }
 #[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl ExternalMemoryFeatureFlags {
-    pub const DEDICATED_ONLY_KHR: Self = Self::DEDICATED_ONLY;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl ExternalMemoryFeatureFlags {
-    pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
-}
-#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
-impl ExternalMemoryFeatureFlags {
-    pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
+impl StructureType {
+    pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: Self =
+        Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
+    pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: Self = Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES;
+    pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: Self =
+        Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
+    pub const EXTERNAL_BUFFER_PROPERTIES_KHR: Self = Self::EXTERNAL_BUFFER_PROPERTIES;
+    pub const PHYSICAL_DEVICE_ID_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_ID_PROPERTIES;
 }
 impl KhrExternalMemoryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_memory\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6081,30 +4705,26 @@ impl KhrExternalMemoryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalMemoryFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_external_memory'"]
-impl StructureType {
-    pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: Self =
-        Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
+impl Result {
+    pub const ERROR_INVALID_EXTERNAL_HANDLE_KHR: Self = Self::ERROR_INVALID_EXTERNAL_HANDLE;
 }
 #[doc = "Generated from 'VK_KHR_external_memory'"]
 impl StructureType {
+    pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: Self =
+        Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
     pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: Self = Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_external_memory'"]
-impl StructureType {
     pub const EXPORT_MEMORY_ALLOCATE_INFO_KHR: Self = Self::EXPORT_MEMORY_ALLOCATE_INFO;
 }
-#[doc = "Generated from 'VK_KHR_external_memory'"]
-impl Result {
-    pub const ERROR_INVALID_EXTERNAL_HANDLE_KHR: Self = Self::ERROR_INVALID_EXTERNAL_HANDLE;
-}
 impl KhrExternalMemoryWin32Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_memory_win32\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_win32\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6133,7 +4753,7 @@ impl KhrExternalMemoryWin32Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalMemoryWin32Fn {
+        Self {
             get_memory_win32_handle_khr: unsafe {
                 unsafe extern "system" fn get_memory_win32_handle_khr(
                     _device: Device,
@@ -6178,51 +4798,18 @@ impl KhrExternalMemoryWin32Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryWin32HandleKHR.html>"]
-    pub unsafe fn get_memory_win32_handle_khr(
-        &self,
-        device: Device,
-        p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR,
-        p_handle: *mut HANDLE,
-    ) -> Result {
-        (self.get_memory_win32_handle_khr)(device, p_get_win32_handle_info, p_handle)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryWin32HandlePropertiesKHR.html>"]
-    pub unsafe fn get_memory_win32_handle_properties_khr(
-        &self,
-        device: Device,
-        handle_type: ExternalMemoryHandleTypeFlags,
-        handle: HANDLE,
-        p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR,
-    ) -> Result {
-        (self.get_memory_win32_handle_properties_khr)(
-            device,
-            handle_type,
-            handle,
-            p_memory_win32_handle_properties,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_external_memory_win32'"]
 impl StructureType {
     pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_000);
-}
-#[doc = "Generated from 'VK_KHR_external_memory_win32'"]
-impl StructureType {
     pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_001);
-}
-#[doc = "Generated from 'VK_KHR_external_memory_win32'"]
-impl StructureType {
     pub const MEMORY_WIN32_HANDLE_PROPERTIES_KHR: Self = Self(1_000_073_002);
-}
-#[doc = "Generated from 'VK_KHR_external_memory_win32'"]
-impl StructureType {
     pub const MEMORY_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_003);
 }
 impl KhrExternalMemoryFdFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_memory_fd\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_fd\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6251,7 +4838,7 @@ impl KhrExternalMemoryFdFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalMemoryFdFn {
+        Self {
             get_memory_fd_khr: unsafe {
                 unsafe extern "system" fn get_memory_fd_khr(
                     _device: Device,
@@ -6292,42 +4879,17 @@ impl KhrExternalMemoryFdFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryFdKHR.html>"]
-    pub unsafe fn get_memory_fd_khr(
-        &self,
-        device: Device,
-        p_get_fd_info: *const MemoryGetFdInfoKHR,
-        p_fd: *mut c_int,
-    ) -> Result {
-        (self.get_memory_fd_khr)(device, p_get_fd_info, p_fd)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryFdPropertiesKHR.html>"]
-    pub unsafe fn get_memory_fd_properties_khr(
-        &self,
-        device: Device,
-        handle_type: ExternalMemoryHandleTypeFlags,
-        fd: c_int,
-        p_memory_fd_properties: *mut MemoryFdPropertiesKHR,
-    ) -> Result {
-        (self.get_memory_fd_properties_khr)(device, handle_type, fd, p_memory_fd_properties)
-    }
 }
 #[doc = "Generated from 'VK_KHR_external_memory_fd'"]
 impl StructureType {
     pub const IMPORT_MEMORY_FD_INFO_KHR: Self = Self(1_000_074_000);
-}
-#[doc = "Generated from 'VK_KHR_external_memory_fd'"]
-impl StructureType {
     pub const MEMORY_FD_PROPERTIES_KHR: Self = Self(1_000_074_001);
-}
-#[doc = "Generated from 'VK_KHR_external_memory_fd'"]
-impl StructureType {
     pub const MEMORY_GET_FD_INFO_KHR: Self = Self(1_000_074_002);
 }
 impl KhrWin32KeyedMutexFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_win32_keyed_mutex\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_keyed_mutex\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6340,7 +4902,7 @@ impl KhrWin32KeyedMutexFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrWin32KeyedMutexFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_win32_keyed_mutex'"]
@@ -6348,9 +4910,13 @@ impl StructureType {
     pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = Self(1_000_075_000);
 }
 impl KhrExternalSemaphoreCapabilitiesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_semaphore_capabilities\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_external_semaphore_capabilities\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6372,7 +4938,7 @@ impl KhrExternalSemaphoreCapabilitiesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalSemaphoreCapabilitiesFn {
+        Self {
             get_physical_device_external_semaphore_properties_khr: unsafe {
                 unsafe extern "system" fn get_physical_device_external_semaphore_properties_khr(
                     _physical_device: PhysicalDevice,
@@ -6396,61 +4962,30 @@ impl KhrExternalSemaphoreCapabilitiesFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html>"]
-    pub unsafe fn get_physical_device_external_semaphore_properties_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
-        p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
-    ) {
-        (self.get_physical_device_external_semaphore_properties_khr)(
-            physical_device,
-            p_external_semaphore_info,
-            p_external_semaphore_properties,
-        )
-    }
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: Self =
-        Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
 }
 #[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
-impl StructureType {
-    pub const EXTERNAL_SEMAPHORE_PROPERTIES_KHR: Self = Self::EXTERNAL_SEMAPHORE_PROPERTIES;
+impl ExternalSemaphoreFeatureFlags {
+    pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
+    pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
 }
 #[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
 impl ExternalSemaphoreHandleTypeFlags {
     pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD;
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
-impl ExternalSemaphoreHandleTypeFlags {
     pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32;
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
-impl ExternalSemaphoreHandleTypeFlags {
     pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT;
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
-impl ExternalSemaphoreHandleTypeFlags {
     pub const D3D12_FENCE_KHR: Self = Self::D3D12_FENCE;
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
-impl ExternalSemaphoreHandleTypeFlags {
     pub const SYNC_FD_KHR: Self = Self::SYNC_FD;
 }
 #[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
-impl ExternalSemaphoreFeatureFlags {
-    pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
-impl ExternalSemaphoreFeatureFlags {
-    pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
+impl StructureType {
+    pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: Self =
+        Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
+    pub const EXTERNAL_SEMAPHORE_PROPERTIES_KHR: Self = Self::EXTERNAL_SEMAPHORE_PROPERTIES;
 }
 impl KhrExternalSemaphoreFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_semaphore\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6463,21 +4998,23 @@ impl KhrExternalSemaphoreFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalSemaphoreFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_external_semaphore'"]
-impl StructureType {
-    pub const EXPORT_SEMAPHORE_CREATE_INFO_KHR: Self = Self::EXPORT_SEMAPHORE_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore'"]
 impl SemaphoreImportFlags {
     pub const TEMPORARY_KHR: Self = Self::TEMPORARY;
 }
+#[doc = "Generated from 'VK_KHR_external_semaphore'"]
+impl StructureType {
+    pub const EXPORT_SEMAPHORE_CREATE_INFO_KHR: Self = Self::EXPORT_SEMAPHORE_CREATE_INFO;
+}
 impl KhrExternalSemaphoreWin32Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_semaphore_win32\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_win32\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6504,7 +5041,7 @@ impl KhrExternalSemaphoreWin32Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalSemaphoreWin32Fn {
+        Self {
             import_semaphore_win32_handle_khr: unsafe {
                 unsafe extern "system" fn import_semaphore_win32_handle_khr(
                     _device: Device,
@@ -6548,44 +5085,20 @@ impl KhrExternalSemaphoreWin32Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkImportSemaphoreWin32HandleKHR.html>"]
-    pub unsafe fn import_semaphore_win32_handle_khr(
-        &self,
-        device: Device,
-        p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR,
-    ) -> Result {
-        (self.import_semaphore_win32_handle_khr)(device, p_import_semaphore_win32_handle_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreWin32HandleKHR.html>"]
-    pub unsafe fn get_semaphore_win32_handle_khr(
-        &self,
-        device: Device,
-        p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR,
-        p_handle: *mut HANDLE,
-    ) -> Result {
-        (self.get_semaphore_win32_handle_khr)(device, p_get_win32_handle_info, p_handle)
-    }
 }
 #[doc = "Generated from 'VK_KHR_external_semaphore_win32'"]
 impl StructureType {
     pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_000);
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_win32'"]
-impl StructureType {
     pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_001);
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_win32'"]
-impl StructureType {
     pub const D3D12_FENCE_SUBMIT_INFO_KHR: Self = Self(1_000_078_002);
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_win32'"]
-impl StructureType {
     pub const SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_003);
 }
 impl KhrExternalSemaphoreFdFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_semaphore_fd\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_fd\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6612,7 +5125,7 @@ impl KhrExternalSemaphoreFdFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalSemaphoreFdFn {
+        Self {
             import_semaphore_fd_khr: unsafe {
                 unsafe extern "system" fn import_semaphore_fd_khr(
                     _device: Device,
@@ -6651,36 +5164,16 @@ impl KhrExternalSemaphoreFdFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkImportSemaphoreFdKHR.html>"]
-    pub unsafe fn import_semaphore_fd_khr(
-        &self,
-        device: Device,
-        p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR,
-    ) -> Result {
-        (self.import_semaphore_fd_khr)(device, p_import_semaphore_fd_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreFdKHR.html>"]
-    pub unsafe fn get_semaphore_fd_khr(
-        &self,
-        device: Device,
-        p_get_fd_info: *const SemaphoreGetFdInfoKHR,
-        p_fd: *mut c_int,
-    ) -> Result {
-        (self.get_semaphore_fd_khr)(device, p_get_fd_info, p_fd)
-    }
 }
 #[doc = "Generated from 'VK_KHR_external_semaphore_fd'"]
 impl StructureType {
     pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = Self(1_000_079_000);
-}
-#[doc = "Generated from 'VK_KHR_external_semaphore_fd'"]
-impl StructureType {
     pub const SEMAPHORE_GET_FD_INFO_KHR: Self = Self(1_000_079_001);
 }
 impl KhrPushDescriptorFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_push_descriptor\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_push_descriptor\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -6713,7 +5206,7 @@ impl KhrPushDescriptorFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrPushDescriptorFn {
+        Self {
             cmd_push_descriptor_set_khr: unsafe {
                 unsafe extern "system" fn cmd_push_descriptor_set_khr(
                     _command_buffer: CommandBuffer,
@@ -6762,59 +5255,27 @@ impl KhrPushDescriptorFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushDescriptorSetKHR.html>"]
-    pub unsafe fn cmd_push_descriptor_set_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        pipeline_bind_point: PipelineBindPoint,
-        layout: PipelineLayout,
-        set: u32,
-        descriptor_write_count: u32,
-        p_descriptor_writes: *const WriteDescriptorSet,
-    ) {
-        (self.cmd_push_descriptor_set_khr)(
-            command_buffer,
-            pipeline_bind_point,
-            layout,
-            set,
-            descriptor_write_count,
-            p_descriptor_writes,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html>"]
-    pub unsafe fn cmd_push_descriptor_set_with_template_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        descriptor_update_template: DescriptorUpdateTemplate,
-        layout: PipelineLayout,
-        set: u32,
-        p_data: *const c_void,
-    ) {
-        (self.cmd_push_descriptor_set_with_template_khr)(
-            command_buffer,
-            descriptor_update_template,
-            layout,
-            set,
-            p_data,
-        )
-    }
-}
-#[doc = "Generated from 'VK_KHR_push_descriptor'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = Self(1_000_080_000);
 }
 #[doc = "Generated from 'VK_KHR_push_descriptor'"]
 impl DescriptorSetLayoutCreateFlags {
+    #[doc = "Descriptors are pushed via flink:vkCmdPushDescriptorSetKHR"]
     pub const PUSH_DESCRIPTOR_KHR: Self = Self(0b1);
 }
 #[doc = "Generated from 'VK_KHR_push_descriptor'"]
 impl DescriptorUpdateTemplateType {
+    #[doc = "Create descriptor update template for pushed descriptor updates"]
     pub const PUSH_DESCRIPTORS_KHR: Self = Self(1);
 }
+#[doc = "Generated from 'VK_KHR_push_descriptor'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = Self(1_000_080_000);
+}
 impl ExtConditionalRenderingFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_conditional_rendering\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conditional_rendering\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -6838,7 +5299,7 @@ impl ExtConditionalRenderingFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtConditionalRenderingFn {
+        Self {
             cmd_begin_conditional_rendering_ext: unsafe {
                 unsafe extern "system" fn cmd_begin_conditional_rendering_ext(
                     _command_buffer: CommandBuffer,
@@ -6880,47 +5341,32 @@ impl ExtConditionalRenderingFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginConditionalRenderingEXT.html>"]
-    pub unsafe fn cmd_begin_conditional_rendering_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT,
-    ) {
-        (self.cmd_begin_conditional_rendering_ext)(command_buffer, p_conditional_rendering_begin)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndConditionalRenderingEXT.html>"]
-    pub unsafe fn cmd_end_conditional_rendering_ext(&self, command_buffer: CommandBuffer) {
-        (self.cmd_end_conditional_rendering_ext)(command_buffer)
-    }
-}
-#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
-impl StructureType {
-    pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: Self = Self(1_000_081_000);
-}
-#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: Self = Self(1_000_081_001);
-}
-#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
-impl StructureType {
-    pub const CONDITIONAL_RENDERING_BEGIN_INFO_EXT: Self = Self(1_000_081_002);
 }
 #[doc = "Generated from 'VK_EXT_conditional_rendering'"]
 impl AccessFlags {
+    #[doc = "read access flag for reading conditional rendering predicate"]
     pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_conditional_rendering'"]
 impl BufferUsageFlags {
+    #[doc = "Specifies the buffer can be used as predicate in conditional rendering"]
     pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b10_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_conditional_rendering'"]
 impl PipelineStageFlags {
+    #[doc = "A pipeline stage for conditional rendering predicate fetch"]
     pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000);
 }
+#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
+impl StructureType {
+    pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: Self = Self(1_000_081_000);
+    pub const PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: Self = Self(1_000_081_001);
+    pub const CONDITIONAL_RENDERING_BEGIN_INFO_EXT: Self = Self(1_000_081_002);
+}
 impl KhrShaderFloat16Int8Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_float16_int8\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float16_int8\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6933,23 +5379,20 @@ impl KhrShaderFloat16Int8Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderFloat16Int8Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_shader_float16_int8'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: Self =
         Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
-}
-#[doc = "Generated from 'VK_KHR_shader_float16_int8'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: Self =
         Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
 }
 impl Khr16bitStorageFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_16bit_storage\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_16bit_storage\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -6962,7 +5405,7 @@ impl Khr16bitStorageFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        Khr16bitStorageFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_16bit_storage'"]
@@ -6971,9 +5414,9 @@ impl StructureType {
         Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
 }
 impl KhrIncrementalPresentFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_incremental_present\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_incremental_present\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -6986,7 +5429,7 @@ impl KhrIncrementalPresentFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrIncrementalPresentFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_incremental_present'"]
@@ -6994,9 +5437,11 @@ impl StructureType {
     pub const PRESENT_REGIONS_KHR: Self = Self(1_000_084_000);
 }
 impl KhrDescriptorUpdateTemplateFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_descriptor_update_template\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_descriptor_update_template\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7035,7 +5480,7 @@ impl KhrDescriptorUpdateTemplateFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDescriptorUpdateTemplateFn {
+        Self {
             create_descriptor_update_template_khr: unsafe {
                 unsafe extern "system" fn create_descriptor_update_template_khr(
                     _device: Device,
@@ -7126,74 +5571,9 @@ impl KhrDescriptorUpdateTemplateFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorUpdateTemplateKHR.html>"]
-    pub unsafe fn create_descriptor_update_template_khr(
-        &self,
-        device: Device,
-        p_create_info: *const DescriptorUpdateTemplateCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_descriptor_update_template: *mut DescriptorUpdateTemplate,
-    ) -> Result {
-        (self.create_descriptor_update_template_khr)(
-            device,
-            p_create_info,
-            p_allocator,
-            p_descriptor_update_template,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorUpdateTemplateKHR.html>"]
-    pub unsafe fn destroy_descriptor_update_template_khr(
-        &self,
-        device: Device,
-        descriptor_update_template: DescriptorUpdateTemplate,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_descriptor_update_template_khr)(
-            device,
-            descriptor_update_template,
-            p_allocator,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateDescriptorSetWithTemplateKHR.html>"]
-    pub unsafe fn update_descriptor_set_with_template_khr(
-        &self,
-        device: Device,
-        descriptor_set: DescriptorSet,
-        descriptor_update_template: DescriptorUpdateTemplate,
-        p_data: *const c_void,
-    ) {
-        (self.update_descriptor_set_with_template_khr)(
-            device,
-            descriptor_set,
-            descriptor_update_template,
-            p_data,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html>"]
-    pub unsafe fn cmd_push_descriptor_set_with_template_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        descriptor_update_template: DescriptorUpdateTemplate,
-        layout: PipelineLayout,
-        set: u32,
-        p_data: *const c_void,
-    ) {
-        (self.cmd_push_descriptor_set_with_template_khr)(
-            command_buffer,
-            descriptor_update_template,
-            layout,
-            set,
-            p_data,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
-impl StructureType {
-    pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: Self =
-        Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
-impl ObjectType {
+impl DebugReportObjectTypeEXT {
     pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE;
 }
 #[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
@@ -7201,13 +5581,20 @@ impl DescriptorUpdateTemplateType {
     pub const DESCRIPTOR_SET_KHR: Self = Self::DESCRIPTOR_SET;
 }
 #[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
-impl DebugReportObjectTypeEXT {
+impl ObjectType {
     pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE;
 }
+#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
+impl StructureType {
+    pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: Self =
+        Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
+}
 impl NvxDeviceGeneratedCommandsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_device_generated_commands\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_device_generated_commands\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -7220,13 +5607,13 @@ impl NvxDeviceGeneratedCommandsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvxDeviceGeneratedCommandsFn {}
+        Self {}
     }
 }
 impl NvClipSpaceWScalingFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_clip_space_w_scaling\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_clip_space_w_scaling\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7248,7 +5635,7 @@ impl NvClipSpaceWScalingFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvClipSpaceWScalingFn {
+        Self {
             cmd_set_viewport_w_scaling_nv: unsafe {
                 unsafe extern "system" fn cmd_set_viewport_w_scaling_nv(
                     _command_buffer: CommandBuffer,
@@ -7273,34 +5660,19 @@ impl NvClipSpaceWScalingFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetViewportWScalingNV.html>"]
-    pub unsafe fn cmd_set_viewport_w_scaling_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        first_viewport: u32,
-        viewport_count: u32,
-        p_viewport_w_scalings: *const ViewportWScalingNV,
-    ) {
-        (self.cmd_set_viewport_w_scaling_nv)(
-            command_buffer,
-            first_viewport,
-            viewport_count,
-            p_viewport_w_scalings,
-        )
-    }
-}
-#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"]
-impl StructureType {
-    pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = Self(1_000_087_000);
 }
 #[doc = "Generated from 'VK_NV_clip_space_w_scaling'"]
 impl DynamicState {
     pub const VIEWPORT_W_SCALING_NV: Self = Self(1_000_087_000);
 }
+#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"]
+impl StructureType {
+    pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = Self(1_000_087_000);
+}
 impl ExtDirectModeDisplayFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_direct_mode_display\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_direct_mode_display\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7318,7 +5690,7 @@ impl ExtDirectModeDisplayFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDirectModeDisplayFn {
+        Self {
             release_display_ext: unsafe {
                 unsafe extern "system" fn release_display_ext(
                     _physical_device: PhysicalDevice,
@@ -7337,19 +5709,11 @@ impl ExtDirectModeDisplayFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkReleaseDisplayEXT.html>"]
-    pub unsafe fn release_display_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        display: DisplayKHR,
-    ) -> Result {
-        (self.release_display_ext)(physical_device, display)
-    }
 }
 impl ExtAcquireXlibDisplayFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_acquire_xlib_display\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_xlib_display\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7378,7 +5742,7 @@ impl ExtAcquireXlibDisplayFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtAcquireXlibDisplayFn {
+        Self {
             acquire_xlib_display_ext: unsafe {
                 unsafe extern "system" fn acquire_xlib_display_ext(
                     _physical_device: PhysicalDevice,
@@ -7423,30 +5787,13 @@ impl ExtAcquireXlibDisplayFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireXlibDisplayEXT.html>"]
-    pub unsafe fn acquire_xlib_display_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        dpy: *mut Display,
-        display: DisplayKHR,
-    ) -> Result {
-        (self.acquire_xlib_display_ext)(physical_device, dpy, display)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRandROutputDisplayEXT.html>"]
-    pub unsafe fn get_rand_r_output_display_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        dpy: *mut Display,
-        rr_output: RROutput,
-        p_display: *mut DisplayKHR,
-    ) -> Result {
-        (self.get_rand_r_output_display_ext)(physical_device, dpy, rr_output, p_display)
-    }
 }
 impl ExtDisplaySurfaceCounterFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_display_surface_counter\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_surface_counter\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7468,7 +5815,7 @@ impl ExtDisplaySurfaceCounterFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDisplaySurfaceCounterFn {
+        Self {
             get_physical_device_surface_capabilities2_ext: unsafe {
                 unsafe extern "system" fn get_physical_device_surface_capabilities2_ext(
                     _physical_device: PhysicalDevice,
@@ -7492,32 +5839,15 @@ impl ExtDisplaySurfaceCounterFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html>"]
-    pub unsafe fn get_physical_device_surface_capabilities2_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        surface: SurfaceKHR,
-        p_surface_capabilities: *mut SurfaceCapabilities2EXT,
-    ) -> Result {
-        (self.get_physical_device_surface_capabilities2_ext)(
-            physical_device,
-            surface,
-            p_surface_capabilities,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_display_surface_counter'"]
 impl StructureType {
     pub const SURFACE_CAPABILITIES_2_EXT: Self = Self(1_000_090_000);
 }
-#[doc = "Generated from 'VK_EXT_display_surface_counter'"]
-impl StructureType {
-    pub const SURFACE_CAPABILITIES2_EXT: Self = Self::SURFACE_CAPABILITIES_2_EXT;
-}
 impl ExtDisplayControlFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_display_control\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_control\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7563,7 +5893,7 @@ impl ExtDisplayControlFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDisplayControlFn {
+        Self {
             display_power_control_ext: unsafe {
                 unsafe extern "system" fn display_power_control_ext(
                     _device: Device,
@@ -7650,73 +5980,18 @@ impl ExtDisplayControlFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDisplayPowerControlEXT.html>"]
-    pub unsafe fn display_power_control_ext(
-        &self,
-        device: Device,
-        display: DisplayKHR,
-        p_display_power_info: *const DisplayPowerInfoEXT,
-    ) -> Result {
-        (self.display_power_control_ext)(device, display, p_display_power_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkRegisterDeviceEventEXT.html>"]
-    pub unsafe fn register_device_event_ext(
-        &self,
-        device: Device,
-        p_device_event_info: *const DeviceEventInfoEXT,
-        p_allocator: *const AllocationCallbacks,
-        p_fence: *mut Fence,
-    ) -> Result {
-        (self.register_device_event_ext)(device, p_device_event_info, p_allocator, p_fence)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkRegisterDisplayEventEXT.html>"]
-    pub unsafe fn register_display_event_ext(
-        &self,
-        device: Device,
-        display: DisplayKHR,
-        p_display_event_info: *const DisplayEventInfoEXT,
-        p_allocator: *const AllocationCallbacks,
-        p_fence: *mut Fence,
-    ) -> Result {
-        (self.register_display_event_ext)(
-            device,
-            display,
-            p_display_event_info,
-            p_allocator,
-            p_fence,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSwapchainCounterEXT.html>"]
-    pub unsafe fn get_swapchain_counter_ext(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-        counter: SurfaceCounterFlagsEXT,
-        p_counter_value: *mut u64,
-    ) -> Result {
-        (self.get_swapchain_counter_ext)(device, swapchain, counter, p_counter_value)
-    }
 }
 #[doc = "Generated from 'VK_EXT_display_control'"]
 impl StructureType {
     pub const DISPLAY_POWER_INFO_EXT: Self = Self(1_000_091_000);
-}
-#[doc = "Generated from 'VK_EXT_display_control'"]
-impl StructureType {
     pub const DEVICE_EVENT_INFO_EXT: Self = Self(1_000_091_001);
-}
-#[doc = "Generated from 'VK_EXT_display_control'"]
-impl StructureType {
     pub const DISPLAY_EVENT_INFO_EXT: Self = Self(1_000_091_002);
-}
-#[doc = "Generated from 'VK_EXT_display_control'"]
-impl StructureType {
     pub const SWAPCHAIN_COUNTER_CREATE_INFO_EXT: Self = Self(1_000_091_003);
 }
 impl GoogleDisplayTimingFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_display_timing\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_display_timing\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7745,7 +6020,7 @@ impl GoogleDisplayTimingFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GoogleDisplayTimingFn {
+        Self {
             get_refresh_cycle_duration_google: unsafe {
                 unsafe extern "system" fn get_refresh_cycle_duration_google(
                     _device: Device,
@@ -7791,39 +6066,38 @@ impl GoogleDisplayTimingFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRefreshCycleDurationGOOGLE.html>"]
-    pub unsafe fn get_refresh_cycle_duration_google(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-        p_display_timing_properties: *mut RefreshCycleDurationGOOGLE,
-    ) -> Result {
-        (self.get_refresh_cycle_duration_google)(device, swapchain, p_display_timing_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPastPresentationTimingGOOGLE.html>"]
-    pub unsafe fn get_past_presentation_timing_google(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-        p_presentation_timing_count: *mut u32,
-        p_presentation_timings: *mut PastPresentationTimingGOOGLE,
-    ) -> Result {
-        (self.get_past_presentation_timing_google)(
-            device,
-            swapchain,
-            p_presentation_timing_count,
-            p_presentation_timings,
-        )
-    }
 }
 #[doc = "Generated from 'VK_GOOGLE_display_timing'"]
 impl StructureType {
     pub const PRESENT_TIMES_INFO_GOOGLE: Self = Self(1_000_092_000);
 }
+impl ReservedDoNotUse94Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_RESERVED_do_not_use_94\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ReservedDoNotUse94Fn {}
+unsafe impl Send for ReservedDoNotUse94Fn {}
+unsafe impl Sync for ReservedDoNotUse94Fn {}
+impl ReservedDoNotUse94Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
 impl NvSampleMaskOverrideCoverageFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_sample_mask_override_coverage\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_NV_sample_mask_override_coverage\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7836,13 +6110,15 @@ impl NvSampleMaskOverrideCoverageFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvSampleMaskOverrideCoverageFn {}
+        Self {}
     }
 }
 impl NvGeometryShaderPassthroughFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_geometry_shader_passthrough\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_geometry_shader_passthrough\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7855,13 +6131,13 @@ impl NvGeometryShaderPassthroughFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvGeometryShaderPassthroughFn {}
+        Self {}
     }
 }
 impl NvViewportArray2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_viewport_array2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_array2\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7874,13 +6150,17 @@ impl NvViewportArray2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvViewportArray2Fn {}
+        Self {}
     }
 }
 impl NvxMultiviewPerViewAttributesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NVX_multiview_per_view_attributes\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_NVX_multiview_per_view_attributes\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7893,7 +6173,7 @@ impl NvxMultiviewPerViewAttributesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvxMultiviewPerViewAttributesFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"]
@@ -7904,15 +6184,12 @@ impl StructureType {
 #[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"]
 impl SubpassDescriptionFlags {
     pub const PER_VIEW_ATTRIBUTES_NVX: Self = Self(0b1);
-}
-#[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"]
-impl SubpassDescriptionFlags {
     pub const PER_VIEW_POSITION_X_ONLY_NVX: Self = Self(0b10);
 }
 impl NvViewportSwizzleFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_viewport_swizzle\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_swizzle\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -7925,7 +6202,7 @@ impl NvViewportSwizzleFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvViewportSwizzleFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_viewport_swizzle'"]
@@ -7933,11 +6210,11 @@ impl StructureType {
     pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = Self(1_000_098_000);
 }
 impl ExtDiscardRectanglesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_discard_rectangles\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_discard_rectangles\0") }
     }
-    pub const SPEC_VERSION: u32 = 1u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn(
@@ -7946,9 +6223,19 @@ pub type PFN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn(
     discard_rectangle_count: u32,
     p_discard_rectangles: *const Rect2D,
 );
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetDiscardRectangleEnableEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, discard_rectangle_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetDiscardRectangleModeEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    discard_rectangle_mode: DiscardRectangleModeEXT,
+);
 #[derive(Clone)]
 pub struct ExtDiscardRectanglesFn {
     pub cmd_set_discard_rectangle_ext: PFN_vkCmdSetDiscardRectangleEXT,
+    pub cmd_set_discard_rectangle_enable_ext: PFN_vkCmdSetDiscardRectangleEnableEXT,
+    pub cmd_set_discard_rectangle_mode_ext: PFN_vkCmdSetDiscardRectangleModeEXT,
 }
 unsafe impl Send for ExtDiscardRectanglesFn {}
 unsafe impl Sync for ExtDiscardRectanglesFn {}
@@ -7957,7 +6244,7 @@ impl ExtDiscardRectanglesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDiscardRectanglesFn {
+        Self {
             cmd_set_discard_rectangle_ext: unsafe {
                 unsafe extern "system" fn cmd_set_discard_rectangle_ext(
                     _command_buffer: CommandBuffer,
@@ -7980,40 +6267,64 @@ impl ExtDiscardRectanglesFn {
                     ::std::mem::transmute(val)
                 }
             },
+            cmd_set_discard_rectangle_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_discard_rectangle_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _discard_rectangle_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_discard_rectangle_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDiscardRectangleEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_discard_rectangle_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_discard_rectangle_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_discard_rectangle_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _discard_rectangle_mode: DiscardRectangleModeEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_discard_rectangle_mode_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDiscardRectangleModeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_discard_rectangle_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDiscardRectangleEXT.html>"]
-    pub unsafe fn cmd_set_discard_rectangle_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        first_discard_rectangle: u32,
-        discard_rectangle_count: u32,
-        p_discard_rectangles: *const Rect2D,
-    ) {
-        (self.cmd_set_discard_rectangle_ext)(
-            command_buffer,
-            first_discard_rectangle,
-            discard_rectangle_count,
-            p_discard_rectangles,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_discard_rectangles'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = Self(1_000_099_000);
+impl DynamicState {
+    pub const DISCARD_RECTANGLE_EXT: Self = Self(1_000_099_000);
+    pub const DISCARD_RECTANGLE_ENABLE_EXT: Self = Self(1_000_099_001);
+    pub const DISCARD_RECTANGLE_MODE_EXT: Self = Self(1_000_099_002);
 }
 #[doc = "Generated from 'VK_EXT_discard_rectangles'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = Self(1_000_099_000);
     pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: Self = Self(1_000_099_001);
 }
-#[doc = "Generated from 'VK_EXT_discard_rectangles'"]
-impl DynamicState {
-    pub const DISCARD_RECTANGLE_EXT: Self = Self(1_000_099_000);
-}
 impl NvExtension101Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_101\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_101\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -8026,13 +6337,15 @@ impl NvExtension101Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension101Fn {}
+        Self {}
     }
 }
 impl ExtConservativeRasterizationFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_conservative_rasterization\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conservative_rasterization\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8045,21 +6358,18 @@ impl ExtConservativeRasterizationFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtConservativeRasterizationFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_conservative_rasterization'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_101_000);
-}
-#[doc = "Generated from 'VK_EXT_conservative_rasterization'"]
-impl StructureType {
     pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = Self(1_000_101_001);
 }
 impl ExtDepthClipEnableFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_depth_clip_enable\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_enable\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8072,21 +6382,18 @@ impl ExtDepthClipEnableFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDepthClipEnableFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_depth_clip_enable'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: Self = Self(1_000_102_000);
-}
-#[doc = "Generated from 'VK_EXT_depth_clip_enable'"]
-impl StructureType {
     pub const PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: Self = Self(1_000_102_001);
 }
 impl NvExtension104Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_104\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_104\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -8099,13 +6406,17 @@ impl NvExtension104Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension104Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_NV_extension_104'"]
+impl PrivateDataSlotCreateFlags {
+    pub const RESERVED_0_NV: Self = Self(0b1);
+}
 impl ExtSwapchainColorspaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_swapchain_colorspace\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_colorspace\0") }
     }
     pub const SPEC_VERSION: u32 = 4u32;
 }
@@ -8118,73 +6429,30 @@ impl ExtSwapchainColorspaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtSwapchainColorspaceFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
 impl ColorSpaceKHR {
     pub const DISPLAY_P3_NONLINEAR_EXT: Self = Self(1_000_104_001);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const EXTENDED_SRGB_LINEAR_EXT: Self = Self(1_000_104_002);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const DISPLAY_P3_LINEAR_EXT: Self = Self(1_000_104_003);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const DCI_P3_NONLINEAR_EXT: Self = Self(1_000_104_004);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const BT709_LINEAR_EXT: Self = Self(1_000_104_005);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const BT709_NONLINEAR_EXT: Self = Self(1_000_104_006);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const BT2020_LINEAR_EXT: Self = Self(1_000_104_007);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const HDR10_ST2084_EXT: Self = Self(1_000_104_008);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const DOLBYVISION_EXT: Self = Self(1_000_104_009);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const HDR10_HLG_EXT: Self = Self(1_000_104_010);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const ADOBERGB_LINEAR_EXT: Self = Self(1_000_104_011);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const ADOBERGB_NONLINEAR_EXT: Self = Self(1_000_104_012);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const PASS_THROUGH_EXT: Self = Self(1_000_104_013);
-}
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
     pub const EXTENDED_SRGB_NONLINEAR_EXT: Self = Self(1_000_104_014);
 }
-#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
-impl ColorSpaceKHR {
-    pub const DCI_P3_LINEAR_EXT: Self = Self::DISPLAY_P3_LINEAR_EXT;
-}
 impl ExtHdrMetadataFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_hdr_metadata\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_hdr_metadata\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -8206,7 +6474,7 @@ impl ExtHdrMetadataFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtHdrMetadataFn {
+        Self {
             set_hdr_metadata_ext: unsafe {
                 unsafe extern "system" fn set_hdr_metadata_ext(
                     _device: Device,
@@ -8227,25 +6495,15 @@ impl ExtHdrMetadataFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetHdrMetadataEXT.html>"]
-    pub unsafe fn set_hdr_metadata_ext(
-        &self,
-        device: Device,
-        swapchain_count: u32,
-        p_swapchains: *const SwapchainKHR,
-        p_metadata: *const HdrMetadataEXT,
-    ) {
-        (self.set_hdr_metadata_ext)(device, swapchain_count, p_swapchains, p_metadata)
-    }
 }
 #[doc = "Generated from 'VK_EXT_hdr_metadata'"]
 impl StructureType {
     pub const HDR_METADATA_EXT: Self = Self(1_000_105_000);
 }
 impl ImgExtension107Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_IMG_extension_107\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_107\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -8258,13 +6516,13 @@ impl ImgExtension107Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ImgExtension107Fn {}
+        Self {}
     }
 }
 impl ImgExtension108Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_IMG_extension_108\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_108\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -8277,13 +6535,15 @@ impl ImgExtension108Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ImgExtension108Fn {}
+        Self {}
     }
 }
 impl KhrImagelessFramebufferFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_imageless_framebuffer\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_imageless_framebuffer\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8296,35 +6556,26 @@ impl KhrImagelessFramebufferFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrImagelessFramebufferFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_imageless_framebuffer'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: Self =
-        Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
+impl FramebufferCreateFlags {
+    pub const IMAGELESS_KHR: Self = Self::IMAGELESS;
 }
 #[doc = "Generated from 'VK_KHR_imageless_framebuffer'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
     pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: Self =
         Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"]
-impl StructureType {
     pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: Self = Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"]
-impl StructureType {
     pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: Self = Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO;
 }
-#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"]
-impl FramebufferCreateFlags {
-    pub const IMAGELESS_KHR: Self = Self::IMAGELESS;
-}
 impl KhrCreateRenderpass2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_create_renderpass2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_create_renderpass2\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8366,7 +6617,7 @@ impl KhrCreateRenderpass2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrCreateRenderpass2Fn {
+        Self {
             create_render_pass2_khr: unsafe {
                 unsafe extern "system" fn create_render_pass2_khr(
                     _device: Device,
@@ -8449,75 +6700,21 @@ impl KhrCreateRenderpass2Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass2KHR.html>"]
-    pub unsafe fn create_render_pass2_khr(
-        &self,
-        device: Device,
-        p_create_info: *const RenderPassCreateInfo2,
-        p_allocator: *const AllocationCallbacks,
-        p_render_pass: *mut RenderPass,
-    ) -> Result {
-        (self.create_render_pass2_khr)(device, p_create_info, p_allocator, p_render_pass)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass2KHR.html>"]
-    pub unsafe fn cmd_begin_render_pass2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_render_pass_begin: *const RenderPassBeginInfo,
-        p_subpass_begin_info: *const SubpassBeginInfo,
-    ) {
-        (self.cmd_begin_render_pass2_khr)(command_buffer, p_render_pass_begin, p_subpass_begin_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass2KHR.html>"]
-    pub unsafe fn cmd_next_subpass2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_subpass_begin_info: *const SubpassBeginInfo,
-        p_subpass_end_info: *const SubpassEndInfo,
-    ) {
-        (self.cmd_next_subpass2_khr)(command_buffer, p_subpass_begin_info, p_subpass_end_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass2KHR.html>"]
-    pub unsafe fn cmd_end_render_pass2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_subpass_end_info: *const SubpassEndInfo,
-    ) {
-        (self.cmd_end_render_pass2_khr)(command_buffer, p_subpass_end_info)
-    }
 }
 #[doc = "Generated from 'VK_KHR_create_renderpass2'"]
 impl StructureType {
     pub const ATTACHMENT_DESCRIPTION_2_KHR: Self = Self::ATTACHMENT_DESCRIPTION_2;
-}
-#[doc = "Generated from 'VK_KHR_create_renderpass2'"]
-impl StructureType {
     pub const ATTACHMENT_REFERENCE_2_KHR: Self = Self::ATTACHMENT_REFERENCE_2;
-}
-#[doc = "Generated from 'VK_KHR_create_renderpass2'"]
-impl StructureType {
     pub const SUBPASS_DESCRIPTION_2_KHR: Self = Self::SUBPASS_DESCRIPTION_2;
-}
-#[doc = "Generated from 'VK_KHR_create_renderpass2'"]
-impl StructureType {
     pub const SUBPASS_DEPENDENCY_2_KHR: Self = Self::SUBPASS_DEPENDENCY_2;
-}
-#[doc = "Generated from 'VK_KHR_create_renderpass2'"]
-impl StructureType {
     pub const RENDER_PASS_CREATE_INFO_2_KHR: Self = Self::RENDER_PASS_CREATE_INFO_2;
-}
-#[doc = "Generated from 'VK_KHR_create_renderpass2'"]
-impl StructureType {
     pub const SUBPASS_BEGIN_INFO_KHR: Self = Self::SUBPASS_BEGIN_INFO;
-}
-#[doc = "Generated from 'VK_KHR_create_renderpass2'"]
-impl StructureType {
     pub const SUBPASS_END_INFO_KHR: Self = Self::SUBPASS_END_INFO;
 }
 impl ImgExtension111Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_IMG_extension_111\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_111\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -8530,13 +6727,15 @@ impl ImgExtension111Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ImgExtension111Fn {}
+        Self {}
     }
 }
 impl KhrSharedPresentableImageFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shared_presentable_image\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shared_presentable_image\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8554,7 +6753,7 @@ impl KhrSharedPresentableImageFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSharedPresentableImageFn {
+        Self {
             get_swapchain_status_khr: unsafe {
                 unsafe extern "system" fn get_swapchain_status_khr(
                     _device: Device,
@@ -8576,35 +6775,26 @@ impl KhrSharedPresentableImageFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSwapchainStatusKHR.html>"]
-    pub unsafe fn get_swapchain_status_khr(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-    ) -> Result {
-        (self.get_swapchain_status_khr)(device, swapchain)
-    }
 }
 #[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
-impl StructureType {
-    pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = Self(1_000_111_000);
+impl ImageLayout {
+    pub const SHARED_PRESENT_KHR: Self = Self(1_000_111_000);
 }
 #[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
 impl PresentModeKHR {
     pub const SHARED_DEMAND_REFRESH: Self = Self(1_000_111_000);
-}
-#[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
-impl PresentModeKHR {
     pub const SHARED_CONTINUOUS_REFRESH: Self = Self(1_000_111_001);
 }
 #[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
-impl ImageLayout {
-    pub const SHARED_PRESENT_KHR: Self = Self(1_000_111_000);
+impl StructureType {
+    pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = Self(1_000_111_000);
 }
 impl KhrExternalFenceCapabilitiesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_fence_capabilities\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_capabilities\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8626,7 +6816,7 @@ impl KhrExternalFenceCapabilitiesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalFenceCapabilitiesFn {
+        Self {
             get_physical_device_external_fence_properties_khr: unsafe {
                 unsafe extern "system" fn get_physical_device_external_fence_properties_khr(
                     _physical_device: PhysicalDevice,
@@ -8650,57 +6840,29 @@ impl KhrExternalFenceCapabilitiesFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html>"]
-    pub unsafe fn get_physical_device_external_fence_properties_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
-        p_external_fence_properties: *mut ExternalFenceProperties,
-    ) {
-        (self.get_physical_device_external_fence_properties_khr)(
-            physical_device,
-            p_external_fence_info,
-            p_external_fence_properties,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: Self =
-        Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
-impl StructureType {
-    pub const EXTERNAL_FENCE_PROPERTIES_KHR: Self = Self::EXTERNAL_FENCE_PROPERTIES;
+impl ExternalFenceFeatureFlags {
+    pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
+    pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
 }
 #[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
 impl ExternalFenceHandleTypeFlags {
     pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD;
-}
-#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
-impl ExternalFenceHandleTypeFlags {
     pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32;
-}
-#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
-impl ExternalFenceHandleTypeFlags {
     pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT;
-}
-#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
-impl ExternalFenceHandleTypeFlags {
     pub const SYNC_FD_KHR: Self = Self::SYNC_FD;
 }
 #[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
-impl ExternalFenceFeatureFlags {
-    pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
-}
-#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
-impl ExternalFenceFeatureFlags {
-    pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
+impl StructureType {
+    pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: Self =
+        Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
+    pub const EXTERNAL_FENCE_PROPERTIES_KHR: Self = Self::EXTERNAL_FENCE_PROPERTIES;
 }
 impl KhrExternalFenceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_fence\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8713,21 +6875,21 @@ impl KhrExternalFenceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalFenceFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_external_fence'"]
-impl StructureType {
-    pub const EXPORT_FENCE_CREATE_INFO_KHR: Self = Self::EXPORT_FENCE_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_external_fence'"]
 impl FenceImportFlags {
     pub const TEMPORARY_KHR: Self = Self::TEMPORARY;
 }
+#[doc = "Generated from 'VK_KHR_external_fence'"]
+impl StructureType {
+    pub const EXPORT_FENCE_CREATE_INFO_KHR: Self = Self::EXPORT_FENCE_CREATE_INFO;
+}
 impl KhrExternalFenceWin32Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_fence_win32\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_win32\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8754,7 +6916,7 @@ impl KhrExternalFenceWin32Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalFenceWin32Fn {
+        Self {
             import_fence_win32_handle_khr: unsafe {
                 unsafe extern "system" fn import_fence_win32_handle_khr(
                     _device: Device,
@@ -8797,40 +6959,17 @@ impl KhrExternalFenceWin32Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkImportFenceWin32HandleKHR.html>"]
-    pub unsafe fn import_fence_win32_handle_khr(
-        &self,
-        device: Device,
-        p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR,
-    ) -> Result {
-        (self.import_fence_win32_handle_khr)(device, p_import_fence_win32_handle_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetFenceWin32HandleKHR.html>"]
-    pub unsafe fn get_fence_win32_handle_khr(
-        &self,
-        device: Device,
-        p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR,
-        p_handle: *mut HANDLE,
-    ) -> Result {
-        (self.get_fence_win32_handle_khr)(device, p_get_win32_handle_info, p_handle)
-    }
 }
 #[doc = "Generated from 'VK_KHR_external_fence_win32'"]
 impl StructureType {
     pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_000);
-}
-#[doc = "Generated from 'VK_KHR_external_fence_win32'"]
-impl StructureType {
     pub const EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_001);
-}
-#[doc = "Generated from 'VK_KHR_external_fence_win32'"]
-impl StructureType {
     pub const FENCE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_002);
 }
 impl KhrExternalFenceFdFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_external_fence_fd\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_fd\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8857,7 +6996,7 @@ impl KhrExternalFenceFdFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExternalFenceFdFn {
+        Self {
             import_fence_fd_khr: unsafe {
                 unsafe extern "system" fn import_fence_fd_khr(
                     _device: Device,
@@ -8892,36 +7031,16 @@ impl KhrExternalFenceFdFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkImportFenceFdKHR.html>"]
-    pub unsafe fn import_fence_fd_khr(
-        &self,
-        device: Device,
-        p_import_fence_fd_info: *const ImportFenceFdInfoKHR,
-    ) -> Result {
-        (self.import_fence_fd_khr)(device, p_import_fence_fd_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetFenceFdKHR.html>"]
-    pub unsafe fn get_fence_fd_khr(
-        &self,
-        device: Device,
-        p_get_fd_info: *const FenceGetFdInfoKHR,
-        p_fd: *mut c_int,
-    ) -> Result {
-        (self.get_fence_fd_khr)(device, p_get_fd_info, p_fd)
-    }
 }
 #[doc = "Generated from 'VK_KHR_external_fence_fd'"]
 impl StructureType {
     pub const IMPORT_FENCE_FD_INFO_KHR: Self = Self(1_000_115_000);
-}
-#[doc = "Generated from 'VK_KHR_external_fence_fd'"]
-impl StructureType {
     pub const FENCE_GET_FD_INFO_KHR: Self = Self(1_000_115_001);
 }
 impl KhrPerformanceQueryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_performance_query\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_performance_query\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -8962,7 +7081,7 @@ impl KhrPerformanceQueryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrPerformanceQueryFn {
+        Self {
             enumerate_physical_device_queue_family_performance_query_counters_khr: unsafe {
                 unsafe extern "system" fn enumerate_physical_device_queue_family_performance_query_counters_khr(
                     _physical_device: PhysicalDevice,
@@ -9046,48 +7165,6 @@ impl KhrPerformanceQueryFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html>"]
-    pub unsafe fn enumerate_physical_device_queue_family_performance_query_counters_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        queue_family_index: u32,
-        p_counter_count: *mut u32,
-        p_counters: *mut PerformanceCounterKHR,
-        p_counter_descriptions: *mut PerformanceCounterDescriptionKHR,
-    ) -> Result {
-        (self.enumerate_physical_device_queue_family_performance_query_counters_khr)(
-            physical_device,
-            queue_family_index,
-            p_counter_count,
-            p_counters,
-            p_counter_descriptions,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html>"]
-    pub unsafe fn get_physical_device_queue_family_performance_query_passes_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_performance_query_create_info: *const QueryPoolPerformanceCreateInfoKHR,
-        p_num_passes: *mut u32,
-    ) {
-        (self.get_physical_device_queue_family_performance_query_passes_khr)(
-            physical_device,
-            p_performance_query_create_info,
-            p_num_passes,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireProfilingLockKHR.html>"]
-    pub unsafe fn acquire_profiling_lock_khr(
-        &self,
-        device: Device,
-        p_info: *const AcquireProfilingLockInfoKHR,
-    ) -> Result {
-        (self.acquire_profiling_lock_khr)(device, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkReleaseProfilingLockKHR.html>"]
-    pub unsafe fn release_profiling_lock_khr(&self, device: Device) {
-        (self.release_profiling_lock_khr)(device)
-    }
 }
 #[doc = "Generated from 'VK_KHR_performance_query'"]
 impl QueryType {
@@ -9096,35 +7173,17 @@ impl QueryType {
 #[doc = "Generated from 'VK_KHR_performance_query'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: Self = Self(1_000_116_000);
-}
-#[doc = "Generated from 'VK_KHR_performance_query'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: Self = Self(1_000_116_001);
-}
-#[doc = "Generated from 'VK_KHR_performance_query'"]
-impl StructureType {
     pub const QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: Self = Self(1_000_116_002);
-}
-#[doc = "Generated from 'VK_KHR_performance_query'"]
-impl StructureType {
     pub const PERFORMANCE_QUERY_SUBMIT_INFO_KHR: Self = Self(1_000_116_003);
-}
-#[doc = "Generated from 'VK_KHR_performance_query'"]
-impl StructureType {
     pub const ACQUIRE_PROFILING_LOCK_INFO_KHR: Self = Self(1_000_116_004);
-}
-#[doc = "Generated from 'VK_KHR_performance_query'"]
-impl StructureType {
     pub const PERFORMANCE_COUNTER_KHR: Self = Self(1_000_116_005);
-}
-#[doc = "Generated from 'VK_KHR_performance_query'"]
-impl StructureType {
     pub const PERFORMANCE_COUNTER_DESCRIPTION_KHR: Self = Self(1_000_116_006);
 }
 impl KhrMaintenance2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_maintenance2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance2\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -9137,66 +7196,45 @@ impl KhrMaintenance2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrMaintenance2Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_maintenance2'"]
 impl ImageCreateFlags {
     pub const BLOCK_TEXEL_VIEW_COMPATIBLE_KHR: Self = Self::BLOCK_TEXEL_VIEW_COMPATIBLE;
-}
-#[doc = "Generated from 'VK_KHR_maintenance2'"]
-impl ImageCreateFlags {
     pub const EXTENDED_USAGE_KHR: Self = Self::EXTENDED_USAGE;
 }
 #[doc = "Generated from 'VK_KHR_maintenance2'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: Self =
-        Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
-}
-#[doc = "Generated from 'VK_KHR_maintenance2'"]
-impl StructureType {
-    pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: Self =
-        Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_maintenance2'"]
-impl StructureType {
-    pub const IMAGE_VIEW_USAGE_CREATE_INFO_KHR: Self = Self::IMAGE_VIEW_USAGE_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_maintenance2'"]
-impl StructureType {
-    pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: Self =
-        Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_maintenance2'"]
 impl ImageLayout {
     pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: Self =
         Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
-}
-#[doc = "Generated from 'VK_KHR_maintenance2'"]
-impl ImageLayout {
     pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: Self =
         Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
 }
 #[doc = "Generated from 'VK_KHR_maintenance2'"]
 impl PointClippingBehavior {
     pub const ALL_CLIP_PLANES_KHR: Self = Self::ALL_CLIP_PLANES;
-}
-#[doc = "Generated from 'VK_KHR_maintenance2'"]
-impl PointClippingBehavior {
     pub const USER_CLIP_PLANES_ONLY_KHR: Self = Self::USER_CLIP_PLANES_ONLY;
 }
 #[doc = "Generated from 'VK_KHR_maintenance2'"]
-impl TessellationDomainOrigin {
-    pub const UPPER_LEFT_KHR: Self = Self::UPPER_LEFT;
+impl StructureType {
+    pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: Self =
+        Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
+    pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: Self =
+        Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
+    pub const IMAGE_VIEW_USAGE_CREATE_INFO_KHR: Self = Self::IMAGE_VIEW_USAGE_CREATE_INFO;
+    pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: Self =
+        Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
 }
 #[doc = "Generated from 'VK_KHR_maintenance2'"]
 impl TessellationDomainOrigin {
+    pub const UPPER_LEFT_KHR: Self = Self::UPPER_LEFT;
     pub const LOWER_LEFT_KHR: Self = Self::LOWER_LEFT;
 }
 impl KhrExtension119Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_119\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_119\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -9209,13 +7247,15 @@ impl KhrExtension119Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension119Fn {}
+        Self {}
     }
 }
 impl KhrGetSurfaceCapabilities2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_get_surface_capabilities2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_surface_capabilities2\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -9245,7 +7285,7 @@ impl KhrGetSurfaceCapabilities2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrGetSurfaceCapabilities2Fn {
+        Self {
             get_physical_device_surface_capabilities2_khr: unsafe {
                 unsafe extern "system" fn get_physical_device_surface_capabilities2_khr(
                     _physical_device: PhysicalDevice,
@@ -9291,51 +7331,17 @@ impl KhrGetSurfaceCapabilities2Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html>"]
-    pub unsafe fn get_physical_device_surface_capabilities2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
-        p_surface_capabilities: *mut SurfaceCapabilities2KHR,
-    ) -> Result {
-        (self.get_physical_device_surface_capabilities2_khr)(
-            physical_device,
-            p_surface_info,
-            p_surface_capabilities,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html>"]
-    pub unsafe fn get_physical_device_surface_formats2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
-        p_surface_format_count: *mut u32,
-        p_surface_formats: *mut SurfaceFormat2KHR,
-    ) -> Result {
-        (self.get_physical_device_surface_formats2_khr)(
-            physical_device,
-            p_surface_info,
-            p_surface_format_count,
-            p_surface_formats,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_get_surface_capabilities2'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = Self(1_000_119_000);
-}
-#[doc = "Generated from 'VK_KHR_get_surface_capabilities2'"]
-impl StructureType {
     pub const SURFACE_CAPABILITIES_2_KHR: Self = Self(1_000_119_001);
-}
-#[doc = "Generated from 'VK_KHR_get_surface_capabilities2'"]
-impl StructureType {
     pub const SURFACE_FORMAT_2_KHR: Self = Self(1_000_119_002);
 }
 impl KhrVariablePointersFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_variable_pointers\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_variable_pointers\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -9348,23 +7354,22 @@ impl KhrVariablePointersFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrVariablePointersFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_variable_pointers'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: Self =
         Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
-}
-#[doc = "Generated from 'VK_KHR_variable_pointers'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: Self =
         Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
 }
 impl KhrGetDisplayProperties2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_get_display_properties2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_display_properties2\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -9408,7 +7413,7 @@ impl KhrGetDisplayProperties2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrGetDisplayProperties2Fn {
+        Self {
             get_physical_device_display_properties2_khr: unsafe {
                 unsafe extern "system" fn get_physical_device_display_properties2_khr(
                     _physical_device: PhysicalDevice,
@@ -9496,85 +7501,19 @@ impl KhrGetDisplayProperties2Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html>"]
-    pub unsafe fn get_physical_device_display_properties2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_property_count: *mut u32,
-        p_properties: *mut DisplayProperties2KHR,
-    ) -> Result {
-        (self.get_physical_device_display_properties2_khr)(
-            physical_device,
-            p_property_count,
-            p_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html>"]
-    pub unsafe fn get_physical_device_display_plane_properties2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_property_count: *mut u32,
-        p_properties: *mut DisplayPlaneProperties2KHR,
-    ) -> Result {
-        (self.get_physical_device_display_plane_properties2_khr)(
-            physical_device,
-            p_property_count,
-            p_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayModeProperties2KHR.html>"]
-    pub unsafe fn get_display_mode_properties2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        display: DisplayKHR,
-        p_property_count: *mut u32,
-        p_properties: *mut DisplayModeProperties2KHR,
-    ) -> Result {
-        (self.get_display_mode_properties2_khr)(
-            physical_device,
-            display,
-            p_property_count,
-            p_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDisplayPlaneCapabilities2KHR.html>"]
-    pub unsafe fn get_display_plane_capabilities2_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_display_plane_info: *const DisplayPlaneInfo2KHR,
-        p_capabilities: *mut DisplayPlaneCapabilities2KHR,
-    ) -> Result {
-        (self.get_display_plane_capabilities2_khr)(
-            physical_device,
-            p_display_plane_info,
-            p_capabilities,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_get_display_properties2'"]
 impl StructureType {
     pub const DISPLAY_PROPERTIES_2_KHR: Self = Self(1_000_121_000);
-}
-#[doc = "Generated from 'VK_KHR_get_display_properties2'"]
-impl StructureType {
     pub const DISPLAY_PLANE_PROPERTIES_2_KHR: Self = Self(1_000_121_001);
-}
-#[doc = "Generated from 'VK_KHR_get_display_properties2'"]
-impl StructureType {
     pub const DISPLAY_MODE_PROPERTIES_2_KHR: Self = Self(1_000_121_002);
-}
-#[doc = "Generated from 'VK_KHR_get_display_properties2'"]
-impl StructureType {
     pub const DISPLAY_PLANE_INFO_2_KHR: Self = Self(1_000_121_003);
-}
-#[doc = "Generated from 'VK_KHR_get_display_properties2'"]
-impl StructureType {
     pub const DISPLAY_PLANE_CAPABILITIES_2_KHR: Self = Self(1_000_121_004);
 }
 impl MvkIosSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_MVK_ios_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_ios_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -9596,7 +7535,7 @@ impl MvkIosSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        MvkIosSurfaceFn {
+        Self {
             create_ios_surface_mvk: unsafe {
                 unsafe extern "system" fn create_ios_surface_mvk(
                     _instance: Instance,
@@ -9620,25 +7559,15 @@ impl MvkIosSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateIOSSurfaceMVK.html>"]
-    pub unsafe fn create_ios_surface_mvk(
-        &self,
-        instance: Instance,
-        p_create_info: *const IOSSurfaceCreateInfoMVK,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_ios_surface_mvk)(instance, p_create_info, p_allocator, p_surface)
-    }
 }
 #[doc = "Generated from 'VK_MVK_ios_surface'"]
 impl StructureType {
     pub const IOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_122_000);
 }
 impl MvkMacosSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_MVK_macos_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_macos_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -9660,7 +7589,7 @@ impl MvkMacosSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        MvkMacosSurfaceFn {
+        Self {
             create_mac_os_surface_mvk: unsafe {
                 unsafe extern "system" fn create_mac_os_surface_mvk(
                     _instance: Instance,
@@ -9684,24 +7613,15 @@ impl MvkMacosSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateMacOSSurfaceMVK.html>"]
-    pub unsafe fn create_mac_os_surface_mvk(
-        &self,
-        instance: Instance,
-        p_create_info: *const MacOSSurfaceCreateInfoMVK,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_mac_os_surface_mvk)(instance, p_create_info, p_allocator, p_surface)
-    }
 }
 #[doc = "Generated from 'VK_MVK_macos_surface'"]
 impl StructureType {
     pub const MACOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_123_000);
 }
 impl MvkMoltenvkFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_MVK_moltenvk\0").expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_moltenvk\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -9714,13 +7634,15 @@ impl MvkMoltenvkFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        MvkMoltenvkFn {}
+        Self {}
     }
 }
 impl ExtExternalMemoryDmaBufFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_external_memory_dma_buf\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_dma_buf\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -9733,7 +7655,7 @@ impl ExtExternalMemoryDmaBufFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExternalMemoryDmaBufFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_external_memory_dma_buf'"]
@@ -9741,9 +7663,9 @@ impl ExternalMemoryHandleTypeFlags {
     pub const DMA_BUF_EXT: Self = Self(0b10_0000_0000);
 }
 impl ExtQueueFamilyForeignFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_queue_family_foreign\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_queue_family_foreign\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -9756,13 +7678,13 @@ impl ExtQueueFamilyForeignFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtQueueFamilyForeignFn {}
+        Self {}
     }
 }
 impl KhrDedicatedAllocationFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_dedicated_allocation\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dedicated_allocation\0") }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -9775,21 +7697,18 @@ impl KhrDedicatedAllocationFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDedicatedAllocationFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_dedicated_allocation'"]
 impl StructureType {
     pub const MEMORY_DEDICATED_REQUIREMENTS_KHR: Self = Self::MEMORY_DEDICATED_REQUIREMENTS;
-}
-#[doc = "Generated from 'VK_KHR_dedicated_allocation'"]
-impl StructureType {
     pub const MEMORY_DEDICATED_ALLOCATE_INFO_KHR: Self = Self::MEMORY_DEDICATED_ALLOCATE_INFO;
 }
 impl ExtDebugUtilsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_debug_utils\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_utils\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -9864,7 +7783,7 @@ impl ExtDebugUtilsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDebugUtilsFn {
+        Self {
             set_debug_utils_object_name_ext: unsafe {
                 unsafe extern "system" fn set_debug_utils_object_name_ext(
                     _device: Device,
@@ -10088,129 +8007,29 @@ impl ExtDebugUtilsFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetDebugUtilsObjectNameEXT.html>"]
-    pub unsafe fn set_debug_utils_object_name_ext(
-        &self,
-        device: Device,
-        p_name_info: *const DebugUtilsObjectNameInfoEXT,
-    ) -> Result {
-        (self.set_debug_utils_object_name_ext)(device, p_name_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetDebugUtilsObjectTagEXT.html>"]
-    pub unsafe fn set_debug_utils_object_tag_ext(
-        &self,
-        device: Device,
-        p_tag_info: *const DebugUtilsObjectTagInfoEXT,
-    ) -> Result {
-        (self.set_debug_utils_object_tag_ext)(device, p_tag_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueBeginDebugUtilsLabelEXT.html>"]
-    pub unsafe fn queue_begin_debug_utils_label_ext(
-        &self,
-        queue: Queue,
-        p_label_info: *const DebugUtilsLabelEXT,
-    ) {
-        (self.queue_begin_debug_utils_label_ext)(queue, p_label_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueEndDebugUtilsLabelEXT.html>"]
-    pub unsafe fn queue_end_debug_utils_label_ext(&self, queue: Queue) {
-        (self.queue_end_debug_utils_label_ext)(queue)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueInsertDebugUtilsLabelEXT.html>"]
-    pub unsafe fn queue_insert_debug_utils_label_ext(
-        &self,
-        queue: Queue,
-        p_label_info: *const DebugUtilsLabelEXT,
-    ) {
-        (self.queue_insert_debug_utils_label_ext)(queue, p_label_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginDebugUtilsLabelEXT.html>"]
-    pub unsafe fn cmd_begin_debug_utils_label_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        p_label_info: *const DebugUtilsLabelEXT,
-    ) {
-        (self.cmd_begin_debug_utils_label_ext)(command_buffer, p_label_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndDebugUtilsLabelEXT.html>"]
-    pub unsafe fn cmd_end_debug_utils_label_ext(&self, command_buffer: CommandBuffer) {
-        (self.cmd_end_debug_utils_label_ext)(command_buffer)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdInsertDebugUtilsLabelEXT.html>"]
-    pub unsafe fn cmd_insert_debug_utils_label_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        p_label_info: *const DebugUtilsLabelEXT,
-    ) {
-        (self.cmd_insert_debug_utils_label_ext)(command_buffer, p_label_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDebugUtilsMessengerEXT.html>"]
-    pub unsafe fn create_debug_utils_messenger_ext(
-        &self,
-        instance: Instance,
-        p_create_info: *const DebugUtilsMessengerCreateInfoEXT,
-        p_allocator: *const AllocationCallbacks,
-        p_messenger: *mut DebugUtilsMessengerEXT,
-    ) -> Result {
-        (self.create_debug_utils_messenger_ext)(instance, p_create_info, p_allocator, p_messenger)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDebugUtilsMessengerEXT.html>"]
-    pub unsafe fn destroy_debug_utils_messenger_ext(
-        &self,
-        instance: Instance,
-        messenger: DebugUtilsMessengerEXT,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_debug_utils_messenger_ext)(instance, messenger, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSubmitDebugUtilsMessageEXT.html>"]
-    pub unsafe fn submit_debug_utils_message_ext(
-        &self,
-        instance: Instance,
-        message_severity: DebugUtilsMessageSeverityFlagsEXT,
-        message_types: DebugUtilsMessageTypeFlagsEXT,
-        p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
-    ) {
-        (self.submit_debug_utils_message_ext)(
-            instance,
-            message_severity,
-            message_types,
-            p_callback_data,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_debug_utils'"]
-impl StructureType {
-    pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = Self(1_000_128_000);
+impl ObjectType {
+    pub const DEBUG_UTILS_MESSENGER_EXT: Self = Self(1_000_128_000);
 }
 #[doc = "Generated from 'VK_EXT_debug_utils'"]
 impl StructureType {
+    pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = Self(1_000_128_000);
     pub const DEBUG_UTILS_OBJECT_TAG_INFO_EXT: Self = Self(1_000_128_001);
-}
-#[doc = "Generated from 'VK_EXT_debug_utils'"]
-impl StructureType {
     pub const DEBUG_UTILS_LABEL_EXT: Self = Self(1_000_128_002);
-}
-#[doc = "Generated from 'VK_EXT_debug_utils'"]
-impl StructureType {
     pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: Self = Self(1_000_128_003);
-}
-#[doc = "Generated from 'VK_EXT_debug_utils'"]
-impl StructureType {
     pub const DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: Self = Self(1_000_128_004);
 }
-#[doc = "Generated from 'VK_EXT_debug_utils'"]
-impl ObjectType {
-    pub const DEBUG_UTILS_MESSENGER_EXT: Self = Self(1_000_128_000);
-}
 impl AndroidExternalMemoryAndroidHardwareBufferFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(
-            b"VK_ANDROID_external_memory_android_hardware_buffer\0",
-        )
-        .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_ANDROID_external_memory_android_hardware_buffer\0",
+            )
+        }
     }
-    pub const SPEC_VERSION: u32 = 3u32;
+    pub const SPEC_VERSION: u32 = 5u32;
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkGetAndroidHardwareBufferPropertiesANDROID = unsafe extern "system" fn(
@@ -10237,7 +8056,7 @@ impl AndroidExternalMemoryAndroidHardwareBufferFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AndroidExternalMemoryAndroidHardwareBufferFn {
+        Self {
             get_android_hardware_buffer_properties_android: unsafe {
                 unsafe extern "system" fn get_android_hardware_buffer_properties_android(
                     _device: Device,
@@ -10282,24 +8101,6 @@ impl AndroidExternalMemoryAndroidHardwareBufferFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html>"]
-    pub unsafe fn get_android_hardware_buffer_properties_android(
-        &self,
-        device: Device,
-        buffer: *const AHardwareBuffer,
-        p_properties: *mut AndroidHardwareBufferPropertiesANDROID,
-    ) -> Result {
-        (self.get_android_hardware_buffer_properties_android)(device, buffer, p_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html>"]
-    pub unsafe fn get_memory_android_hardware_buffer_android(
-        &self,
-        device: Device,
-        p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID,
-        p_buffer: *mut *mut AHardwareBuffer,
-    ) -> Result {
-        (self.get_memory_android_hardware_buffer_android)(device, p_info, p_buffer)
-    }
 }
 #[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
 impl ExternalMemoryHandleTypeFlags {
@@ -10308,31 +8109,19 @@ impl ExternalMemoryHandleTypeFlags {
 #[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
 impl StructureType {
     pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = Self(1_000_129_000);
-}
-#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
-impl StructureType {
     pub const ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: Self = Self(1_000_129_001);
-}
-#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
-impl StructureType {
     pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: Self = Self(1_000_129_002);
-}
-#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
-impl StructureType {
     pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_003);
-}
-#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
-impl StructureType {
     pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_004);
-}
-#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
-impl StructureType {
     pub const EXTERNAL_FORMAT_ANDROID: Self = Self(1_000_129_005);
+    pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: Self = Self(1_000_129_006);
 }
 impl ExtSamplerFilterMinmaxFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_sampler_filter_minmax\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sampler_filter_minmax\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -10345,39 +8134,34 @@ impl ExtSamplerFilterMinmaxFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtSamplerFilterMinmaxFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self =
-        Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
-}
-#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
-impl StructureType {
-    pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self =
-        Self::SAMPLER_REDUCTION_MODE_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
 impl FormatFeatureFlags {
     pub const SAMPLED_IMAGE_FILTER_MINMAX_EXT: Self = Self::SAMPLED_IMAGE_FILTER_MINMAX;
 }
 #[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
 impl SamplerReductionMode {
     pub const WEIGHTED_AVERAGE_EXT: Self = Self::WEIGHTED_AVERAGE;
-}
-#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
-impl SamplerReductionMode {
     pub const MIN_EXT: Self = Self::MIN;
+    pub const MAX_EXT: Self = Self::MAX;
 }
 #[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
-impl SamplerReductionMode {
-    pub const MAX_EXT: Self = Self::MAX;
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self =
+        Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
+    pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self =
+        Self::SAMPLER_REDUCTION_MODE_CREATE_INFO;
 }
 impl KhrStorageBufferStorageClassFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_storage_buffer_storage_class\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_storage_buffer_storage_class\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -10390,13 +8174,13 @@ impl KhrStorageBufferStorageClassFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrStorageBufferStorageClassFn {}
+        Self {}
     }
 }
 impl AmdGpuShaderInt16Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_gpu_shader_int16\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_int16\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -10409,13 +8193,13 @@ impl AmdGpuShaderInt16Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdGpuShaderInt16Fn {}
+        Self {}
     }
 }
 impl AmdExtension134Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_134\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_134\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -10428,13 +8212,13 @@ impl AmdExtension134Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension134Fn {}
+        Self {}
     }
 }
 impl AmdExtension135Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_135\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_135\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -10447,13 +8231,17 @@ impl AmdExtension135Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension135Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_AMD_extension_135'"]
+impl BufferUsageFlags {
+    pub const RESERVED_25_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
+}
 impl AmdExtension136Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_136\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_136\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -10466,13 +8254,15 @@ impl AmdExtension136Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension136Fn {}
+        Self {}
     }
 }
 impl AmdMixedAttachmentSamplesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_mixed_attachment_samples\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_mixed_attachment_samples\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -10485,13 +8275,13 @@ impl AmdMixedAttachmentSamplesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdMixedAttachmentSamplesFn {}
+        Self {}
     }
 }
 impl AmdShaderFragmentMaskFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_fragment_mask\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_fragment_mask\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -10504,13 +8294,13 @@ impl AmdShaderFragmentMaskFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdShaderFragmentMaskFn {}
+        Self {}
     }
 }
 impl ExtInlineUniformBlockFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_inline_uniform_block\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_inline_uniform_block\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -10523,33 +8313,28 @@ impl ExtInlineUniformBlockFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtInlineUniformBlockFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_inline_uniform_block'"]
 impl DescriptorType {
-    pub const INLINE_UNIFORM_BLOCK_EXT: Self = Self(1_000_138_000);
+    pub const INLINE_UNIFORM_BLOCK_EXT: Self = Self::INLINE_UNIFORM_BLOCK;
 }
 #[doc = "Generated from 'VK_EXT_inline_uniform_block'"]
 impl StructureType {
-    pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: Self = Self(1_000_138_000);
-}
-#[doc = "Generated from 'VK_EXT_inline_uniform_block'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: Self = Self(1_000_138_001);
-}
-#[doc = "Generated from 'VK_EXT_inline_uniform_block'"]
-impl StructureType {
-    pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: Self = Self(1_000_138_002);
-}
-#[doc = "Generated from 'VK_EXT_inline_uniform_block'"]
-impl StructureType {
-    pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: Self = Self(1_000_138_003);
+    pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: Self =
+        Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
+    pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: Self =
+        Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
+    pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: Self =
+        Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
+    pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: Self =
+        Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
 }
 impl AmdExtension140Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_140\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_140\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -10562,13 +8347,15 @@ impl AmdExtension140Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension140Fn {}
+        Self {}
     }
 }
 impl ExtShaderStencilExportFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_stencil_export\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_stencil_export\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -10581,13 +8368,13 @@ impl ExtShaderStencilExportFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtShaderStencilExportFn {}
+        Self {}
     }
 }
 impl AmdExtension142Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_142\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_142\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -10600,13 +8387,13 @@ impl AmdExtension142Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension142Fn {}
+        Self {}
     }
 }
 impl AmdExtension143Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_143\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_143\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -10619,13 +8406,13 @@ impl AmdExtension143Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension143Fn {}
+        Self {}
     }
 }
 impl ExtSampleLocationsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_sample_locations\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sample_locations\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -10653,7 +8440,7 @@ impl ExtSampleLocationsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtSampleLocationsFn {
+        Self {
             cmd_set_sample_locations_ext: unsafe {
                 unsafe extern "system" fn cmd_set_sample_locations_ext(
                     _command_buffer: CommandBuffer,
@@ -10697,27 +8484,10 @@ impl ExtSampleLocationsFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetSampleLocationsEXT.html>"]
-    pub unsafe fn cmd_set_sample_locations_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        p_sample_locations_info: *const SampleLocationsInfoEXT,
-    ) {
-        (self.cmd_set_sample_locations_ext)(command_buffer, p_sample_locations_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html>"]
-    pub unsafe fn get_physical_device_multisample_properties_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        samples: SampleCountFlags,
-        p_multisample_properties: *mut MultisamplePropertiesEXT,
-    ) {
-        (self.get_physical_device_multisample_properties_ext)(
-            physical_device,
-            samples,
-            p_multisample_properties,
-        )
-    }
+}
+#[doc = "Generated from 'VK_EXT_sample_locations'"]
+impl DynamicState {
+    pub const SAMPLE_LOCATIONS_EXT: Self = Self(1_000_143_000);
 }
 #[doc = "Generated from 'VK_EXT_sample_locations'"]
 impl ImageCreateFlags {
@@ -10726,31 +8496,15 @@ impl ImageCreateFlags {
 #[doc = "Generated from 'VK_EXT_sample_locations'"]
 impl StructureType {
     pub const SAMPLE_LOCATIONS_INFO_EXT: Self = Self(1_000_143_000);
-}
-#[doc = "Generated from 'VK_EXT_sample_locations'"]
-impl StructureType {
     pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: Self = Self(1_000_143_001);
-}
-#[doc = "Generated from 'VK_EXT_sample_locations'"]
-impl StructureType {
     pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: Self = Self(1_000_143_002);
-}
-#[doc = "Generated from 'VK_EXT_sample_locations'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: Self = Self(1_000_143_003);
-}
-#[doc = "Generated from 'VK_EXT_sample_locations'"]
-impl StructureType {
     pub const MULTISAMPLE_PROPERTIES_EXT: Self = Self(1_000_143_004);
 }
-#[doc = "Generated from 'VK_EXT_sample_locations'"]
-impl DynamicState {
-    pub const SAMPLE_LOCATIONS_EXT: Self = Self(1_000_143_000);
-}
 impl KhrRelaxedBlockLayoutFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_relaxed_block_layout\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_relaxed_block_layout\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -10763,13 +8517,34 @@ impl KhrRelaxedBlockLayoutFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrRelaxedBlockLayoutFn {}
+        Self {}
+    }
+}
+impl ReservedDoNotUse146Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_RESERVED_do_not_use_146\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ReservedDoNotUse146Fn {}
+unsafe impl Send for ReservedDoNotUse146Fn {}
+unsafe impl Sync for ReservedDoNotUse146Fn {}
+impl ReservedDoNotUse146Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
     }
 }
 impl KhrGetMemoryRequirements2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_get_memory_requirements2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_memory_requirements2\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -10805,7 +8580,7 @@ impl KhrGetMemoryRequirements2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrGetMemoryRequirements2Fn {
+        Self {
             get_image_memory_requirements2_khr: unsafe {
                 unsafe extern "system" fn get_image_memory_requirements2_khr(
                     _device: Device,
@@ -10872,66 +8647,21 @@ impl KhrGetMemoryRequirements2Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements2KHR.html>"]
-    pub unsafe fn get_image_memory_requirements2_khr(
-        &self,
-        device: Device,
-        p_info: *const ImageMemoryRequirementsInfo2,
-        p_memory_requirements: *mut MemoryRequirements2,
-    ) {
-        (self.get_image_memory_requirements2_khr)(device, p_info, p_memory_requirements)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements2KHR.html>"]
-    pub unsafe fn get_buffer_memory_requirements2_khr(
-        &self,
-        device: Device,
-        p_info: *const BufferMemoryRequirementsInfo2,
-        p_memory_requirements: *mut MemoryRequirements2,
-    ) {
-        (self.get_buffer_memory_requirements2_khr)(device, p_info, p_memory_requirements)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements2KHR.html>"]
-    pub unsafe fn get_image_sparse_memory_requirements2_khr(
-        &self,
-        device: Device,
-        p_info: *const ImageSparseMemoryRequirementsInfo2,
-        p_sparse_memory_requirement_count: *mut u32,
-        p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
-    ) {
-        (self.get_image_sparse_memory_requirements2_khr)(
-            device,
-            p_info,
-            p_sparse_memory_requirement_count,
-            p_sparse_memory_requirements,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_get_memory_requirements2'"]
 impl StructureType {
     pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2;
-}
-#[doc = "Generated from 'VK_KHR_get_memory_requirements2'"]
-impl StructureType {
     pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2;
-}
-#[doc = "Generated from 'VK_KHR_get_memory_requirements2'"]
-impl StructureType {
     pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self =
         Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
-}
-#[doc = "Generated from 'VK_KHR_get_memory_requirements2'"]
-impl StructureType {
     pub const MEMORY_REQUIREMENTS_2_KHR: Self = Self::MEMORY_REQUIREMENTS_2;
-}
-#[doc = "Generated from 'VK_KHR_get_memory_requirements2'"]
-impl StructureType {
     pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: Self =
         Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
 }
 impl KhrImageFormatListFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_image_format_list\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_image_format_list\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -10944,7 +8674,7 @@ impl KhrImageFormatListFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrImageFormatListFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_image_format_list'"]
@@ -10952,9 +8682,11 @@ impl StructureType {
     pub const IMAGE_FORMAT_LIST_CREATE_INFO_KHR: Self = Self::IMAGE_FORMAT_LIST_CREATE_INFO;
 }
 impl ExtBlendOperationAdvancedFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_blend_operation_advanced\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_blend_operation_advanced\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -10967,213 +8699,74 @@ impl ExtBlendOperationAdvancedFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtBlendOperationAdvancedFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = Self(1_000_148_000);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = Self(1_000_148_001);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl StructureType {
-    pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = Self(1_000_148_002);
+impl AccessFlags {
+    pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
 impl BlendOp {
     pub const ZERO_EXT: Self = Self(1_000_148_000);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const SRC_EXT: Self = Self(1_000_148_001);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const DST_EXT: Self = Self(1_000_148_002);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const SRC_OVER_EXT: Self = Self(1_000_148_003);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const DST_OVER_EXT: Self = Self(1_000_148_004);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const SRC_IN_EXT: Self = Self(1_000_148_005);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const DST_IN_EXT: Self = Self(1_000_148_006);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const SRC_OUT_EXT: Self = Self(1_000_148_007);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const DST_OUT_EXT: Self = Self(1_000_148_008);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const SRC_ATOP_EXT: Self = Self(1_000_148_009);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const DST_ATOP_EXT: Self = Self(1_000_148_010);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const XOR_EXT: Self = Self(1_000_148_011);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const MULTIPLY_EXT: Self = Self(1_000_148_012);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const SCREEN_EXT: Self = Self(1_000_148_013);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const OVERLAY_EXT: Self = Self(1_000_148_014);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const DARKEN_EXT: Self = Self(1_000_148_015);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const LIGHTEN_EXT: Self = Self(1_000_148_016);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const COLORDODGE_EXT: Self = Self(1_000_148_017);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const COLORBURN_EXT: Self = Self(1_000_148_018);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const HARDLIGHT_EXT: Self = Self(1_000_148_019);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const SOFTLIGHT_EXT: Self = Self(1_000_148_020);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const DIFFERENCE_EXT: Self = Self(1_000_148_021);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const EXCLUSION_EXT: Self = Self(1_000_148_022);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const INVERT_EXT: Self = Self(1_000_148_023);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const INVERT_RGB_EXT: Self = Self(1_000_148_024);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const LINEARDODGE_EXT: Self = Self(1_000_148_025);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const LINEARBURN_EXT: Self = Self(1_000_148_026);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const VIVIDLIGHT_EXT: Self = Self(1_000_148_027);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const LINEARLIGHT_EXT: Self = Self(1_000_148_028);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const PINLIGHT_EXT: Self = Self(1_000_148_029);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const HARDMIX_EXT: Self = Self(1_000_148_030);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const HSL_HUE_EXT: Self = Self(1_000_148_031);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const HSL_SATURATION_EXT: Self = Self(1_000_148_032);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const HSL_COLOR_EXT: Self = Self(1_000_148_033);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const HSL_LUMINOSITY_EXT: Self = Self(1_000_148_034);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const PLUS_EXT: Self = Self(1_000_148_035);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const PLUS_CLAMPED_EXT: Self = Self(1_000_148_036);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const PLUS_CLAMPED_ALPHA_EXT: Self = Self(1_000_148_037);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const PLUS_DARKER_EXT: Self = Self(1_000_148_038);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const MINUS_EXT: Self = Self(1_000_148_039);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const MINUS_CLAMPED_EXT: Self = Self(1_000_148_040);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const CONTRAST_EXT: Self = Self(1_000_148_041);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const INVERT_OVG_EXT: Self = Self(1_000_148_042);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const RED_EXT: Self = Self(1_000_148_043);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const GREEN_EXT: Self = Self(1_000_148_044);
-}
-#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl BlendOp {
     pub const BLUE_EXT: Self = Self(1_000_148_045);
 }
 #[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
-impl AccessFlags {
-    pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = Self(1_000_148_000);
+    pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = Self(1_000_148_001);
+    pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = Self(1_000_148_002);
 }
 impl NvFragmentCoverageToColorFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_fragment_coverage_to_color\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_coverage_to_color\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -11186,7 +8779,7 @@ impl NvFragmentCoverageToColorFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvFragmentCoverageToColorFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_fragment_coverage_to_color'"]
@@ -11194,11 +8787,13 @@ impl StructureType {
     pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = Self(1_000_149_000);
 }
 impl KhrAccelerationStructureFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_acceleration_structure\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_acceleration_structure\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 12u32;
+    pub const SPEC_VERSION: u32 = 13u32;
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn(
@@ -11342,7 +8937,7 @@ impl KhrAccelerationStructureFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrAccelerationStructureFn {
+        Self {
             create_acceleration_structure_khr: unsafe {
                 unsafe extern "system" fn create_acceleration_structure_khr(
                     _device: Device,
@@ -11693,325 +9288,75 @@ impl KhrAccelerationStructureFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateAccelerationStructureKHR.html>"]
-    pub unsafe fn create_acceleration_structure_khr(
-        &self,
-        device: Device,
-        p_create_info: *const AccelerationStructureCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_acceleration_structure: *mut AccelerationStructureKHR,
-    ) -> Result {
-        (self.create_acceleration_structure_khr)(
-            device,
-            p_create_info,
-            p_allocator,
-            p_acceleration_structure,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyAccelerationStructureKHR.html>"]
-    pub unsafe fn destroy_acceleration_structure_khr(
-        &self,
-        device: Device,
-        acceleration_structure: AccelerationStructureKHR,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_acceleration_structure_khr)(device, acceleration_structure, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBuildAccelerationStructuresKHR.html>"]
-    pub unsafe fn cmd_build_acceleration_structures_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        info_count: u32,
-        p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
-        pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
-    ) {
-        (self.cmd_build_acceleration_structures_khr)(
-            command_buffer,
-            info_count,
-            p_infos,
-            pp_build_range_infos,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html>"]
-    pub unsafe fn cmd_build_acceleration_structures_indirect_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        info_count: u32,
-        p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
-        p_indirect_device_addresses: *const DeviceAddress,
-        p_indirect_strides: *const u32,
-        pp_max_primitive_counts: *const *const u32,
-    ) {
-        (self.cmd_build_acceleration_structures_indirect_khr)(
-            command_buffer,
-            info_count,
-            p_infos,
-            p_indirect_device_addresses,
-            p_indirect_strides,
-            pp_max_primitive_counts,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBuildAccelerationStructuresKHR.html>"]
-    pub unsafe fn build_acceleration_structures_khr(
-        &self,
-        device: Device,
-        deferred_operation: DeferredOperationKHR,
-        info_count: u32,
-        p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
-        pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
-    ) -> Result {
-        (self.build_acceleration_structures_khr)(
-            device,
-            deferred_operation,
-            info_count,
-            p_infos,
-            pp_build_range_infos,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCopyAccelerationStructureKHR.html>"]
-    pub unsafe fn copy_acceleration_structure_khr(
-        &self,
-        device: Device,
-        deferred_operation: DeferredOperationKHR,
-        p_info: *const CopyAccelerationStructureInfoKHR,
-    ) -> Result {
-        (self.copy_acceleration_structure_khr)(device, deferred_operation, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCopyAccelerationStructureToMemoryKHR.html>"]
-    pub unsafe fn copy_acceleration_structure_to_memory_khr(
-        &self,
-        device: Device,
-        deferred_operation: DeferredOperationKHR,
-        p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
-    ) -> Result {
-        (self.copy_acceleration_structure_to_memory_khr)(device, deferred_operation, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCopyMemoryToAccelerationStructureKHR.html>"]
-    pub unsafe fn copy_memory_to_acceleration_structure_khr(
-        &self,
-        device: Device,
-        deferred_operation: DeferredOperationKHR,
-        p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
-    ) -> Result {
-        (self.copy_memory_to_acceleration_structure_khr)(device, deferred_operation, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWriteAccelerationStructuresPropertiesKHR.html>"]
-    pub unsafe fn write_acceleration_structures_properties_khr(
-        &self,
-        device: Device,
-        acceleration_structure_count: u32,
-        p_acceleration_structures: *const AccelerationStructureKHR,
-        query_type: QueryType,
-        data_size: usize,
-        p_data: *mut c_void,
-        stride: usize,
-    ) -> Result {
-        (self.write_acceleration_structures_properties_khr)(
-            device,
-            acceleration_structure_count,
-            p_acceleration_structures,
-            query_type,
-            data_size,
-            p_data,
-            stride,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyAccelerationStructureKHR.html>"]
-    pub unsafe fn cmd_copy_acceleration_structure_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_info: *const CopyAccelerationStructureInfoKHR,
-    ) {
-        (self.cmd_copy_acceleration_structure_khr)(command_buffer, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html>"]
-    pub unsafe fn cmd_copy_acceleration_structure_to_memory_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
-    ) {
-        (self.cmd_copy_acceleration_structure_to_memory_khr)(command_buffer, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html>"]
-    pub unsafe fn cmd_copy_memory_to_acceleration_structure_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
-    ) {
-        (self.cmd_copy_memory_to_acceleration_structure_khr)(command_buffer, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetAccelerationStructureDeviceAddressKHR.html>"]
-    pub unsafe fn get_acceleration_structure_device_address_khr(
-        &self,
-        device: Device,
-        p_info: *const AccelerationStructureDeviceAddressInfoKHR,
-    ) -> DeviceAddress {
-        (self.get_acceleration_structure_device_address_khr)(device, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html>"]
-    pub unsafe fn cmd_write_acceleration_structures_properties_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        acceleration_structure_count: u32,
-        p_acceleration_structures: *const AccelerationStructureKHR,
-        query_type: QueryType,
-        query_pool: QueryPool,
-        first_query: u32,
-    ) {
-        (self.cmd_write_acceleration_structures_properties_khr)(
-            command_buffer,
-            acceleration_structure_count,
-            p_acceleration_structures,
-            query_type,
-            query_pool,
-            first_query,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html>"]
-    pub unsafe fn get_device_acceleration_structure_compatibility_khr(
-        &self,
-        device: Device,
-        p_version_info: *const AccelerationStructureVersionInfoKHR,
-        p_compatibility: *mut AccelerationStructureCompatibilityKHR,
-    ) {
-        (self.get_device_acceleration_structure_compatibility_khr)(
-            device,
-            p_version_info,
-            p_compatibility,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetAccelerationStructureBuildSizesKHR.html>"]
-    pub unsafe fn get_acceleration_structure_build_sizes_khr(
-        &self,
-        device: Device,
-        build_type: AccelerationStructureBuildTypeKHR,
-        p_build_info: *const AccelerationStructureBuildGeometryInfoKHR,
-        p_max_primitive_counts: *const u32,
-        p_size_info: *mut AccelerationStructureBuildSizesInfoKHR,
-    ) {
-        (self.get_acceleration_structure_build_sizes_khr)(
-            device,
-            build_type,
-            p_build_info,
-            p_max_primitive_counts,
-            p_size_info,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_007);
+impl AccessFlags {
+    pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
+    pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: Self = Self(1_000_150_000);
+impl BufferUsageFlags {
+    pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR: Self =
+        Self(0b1000_0000_0000_0000_0000);
+    pub const ACCELERATION_STRUCTURE_STORAGE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: Self = Self(1_000_150_002);
+impl DebugReportObjectTypeEXT {
+    pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: Self = Self(1_000_150_003);
+impl DescriptorType {
+    pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: Self = Self(1_000_150_004);
+impl FormatFeatureFlags {
+    pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: Self = Self(1_000_150_005);
+impl FormatFeatureFlags2 {
+    pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_GEOMETRY_KHR: Self = Self(1_000_150_006);
+impl IndexType {
+    pub const NONE_KHR: Self = Self(1_000_165_000);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_VERSION_INFO_KHR: Self = Self(1_000_150_009);
+impl ObjectType {
+    pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const COPY_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_010);
+impl PipelineStageFlags {
+    pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
-    pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: Self = Self(1_000_150_011);
+impl QueryType {
+    pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: Self = Self(1_000_150_000);
+    pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: Self = Self(1_000_150_001);
 }
 #[doc = "Generated from 'VK_KHR_acceleration_structure'"]
 impl StructureType {
+    pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_007);
+    pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: Self = Self(1_000_150_000);
+    pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: Self = Self(1_000_150_002);
+    pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: Self = Self(1_000_150_003);
+    pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: Self = Self(1_000_150_004);
+    pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: Self = Self(1_000_150_005);
+    pub const ACCELERATION_STRUCTURE_GEOMETRY_KHR: Self = Self(1_000_150_006);
+    pub const ACCELERATION_STRUCTURE_VERSION_INFO_KHR: Self = Self(1_000_150_009);
+    pub const COPY_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_010);
+    pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: Self = Self(1_000_150_011);
     pub const COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_012);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: Self = Self(1_000_150_013);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: Self = Self(1_000_150_014);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
     pub const ACCELERATION_STRUCTURE_CREATE_INFO_KHR: Self = Self(1_000_150_017);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl StructureType {
     pub const ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: Self = Self(1_000_150_020);
 }
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl PipelineStageFlags {
-    pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl DescriptorType {
-    pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl AccessFlags {
-    pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl AccessFlags {
-    pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl QueryType {
-    pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: Self = Self(1_000_150_000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl QueryType {
-    pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: Self = Self(1_000_150_001);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl ObjectType {
-    pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl DebugReportObjectTypeEXT {
-    pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl IndexType {
-    pub const NONE_KHR: Self = Self(1_000_165_000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl FormatFeatureFlags {
-    pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self =
-        Self(0b10_0000_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl BufferUsageFlags {
-    pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR: Self =
-        Self(0b1000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
-impl BufferUsageFlags {
-    pub const ACCELERATION_STRUCTURE_STORAGE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000);
-}
 impl KhrRayTracingPipelineFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_ray_tracing_pipeline\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_pipeline\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -12092,7 +9437,7 @@ impl KhrRayTracingPipelineFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrRayTracingPipelineFn {
+        Self {
             cmd_trace_rays_khr: unsafe {
                 unsafe extern "system" fn cmd_trace_rays_khr(
                     _command_buffer: CommandBuffer,
@@ -12254,219 +9599,55 @@ impl KhrRayTracingPipelineFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdTraceRaysKHR.html>"]
-    pub unsafe fn cmd_trace_rays_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
-        p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
-        p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
-        p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
-        width: u32,
-        height: u32,
-        depth: u32,
-    ) {
-        (self.cmd_trace_rays_khr)(
-            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,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRayTracingPipelinesKHR.html>"]
-    pub unsafe fn create_ray_tracing_pipelines_khr(
-        &self,
-        device: Device,
-        deferred_operation: DeferredOperationKHR,
-        pipeline_cache: PipelineCache,
-        create_info_count: u32,
-        p_create_infos: *const RayTracingPipelineCreateInfoKHR,
-        p_allocator: *const AllocationCallbacks,
-        p_pipelines: *mut Pipeline,
-    ) -> Result {
-        (self.create_ray_tracing_pipelines_khr)(
-            device,
-            deferred_operation,
-            pipeline_cache,
-            create_info_count,
-            p_create_infos,
-            p_allocator,
-            p_pipelines,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRayTracingShaderGroupHandlesKHR.html>"]
-    pub unsafe fn get_ray_tracing_shader_group_handles_khr(
-        &self,
-        device: Device,
-        pipeline: Pipeline,
-        first_group: u32,
-        group_count: u32,
-        data_size: usize,
-        p_data: *mut c_void,
-    ) -> Result {
-        (self.get_ray_tracing_shader_group_handles_khr)(
-            device,
-            pipeline,
-            first_group,
-            group_count,
-            data_size,
-            p_data,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html>"]
-    pub unsafe fn get_ray_tracing_capture_replay_shader_group_handles_khr(
-        &self,
-        device: Device,
-        pipeline: Pipeline,
-        first_group: u32,
-        group_count: u32,
-        data_size: usize,
-        p_data: *mut c_void,
-    ) -> Result {
-        (self.get_ray_tracing_capture_replay_shader_group_handles_khr)(
-            device,
-            pipeline,
-            first_group,
-            group_count,
-            data_size,
-            p_data,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdTraceRaysIndirectKHR.html>"]
-    pub unsafe fn cmd_trace_rays_indirect_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
-        p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
-        p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
-        p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
-        indirect_device_address: DeviceAddress,
-    ) {
-        (self.cmd_trace_rays_indirect_khr)(
-            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,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html>"]
-    pub unsafe fn get_ray_tracing_shader_group_stack_size_khr(
-        &self,
-        device: Device,
-        pipeline: Pipeline,
-        group: u32,
-        group_shader: ShaderGroupShaderKHR,
-    ) -> DeviceSize {
-        (self.get_ray_tracing_shader_group_stack_size_khr)(device, pipeline, group, group_shader)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html>"]
-    pub unsafe fn cmd_set_ray_tracing_pipeline_stack_size_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        pipeline_stack_size: u32,
-    ) {
-        (self.cmd_set_ray_tracing_pipeline_stack_size_khr)(command_buffer, pipeline_stack_size)
-    }
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: Self = Self(1_000_347_000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: Self = Self(1_000_347_001);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl StructureType {
-    pub const RAY_TRACING_PIPELINE_CREATE_INFO_KHR: Self = Self(1_000_150_015);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl StructureType {
-    pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: Self = Self(1_000_150_016);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl StructureType {
-    pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: Self = Self(1_000_150_018);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl ShaderStageFlags {
-    pub const RAYGEN_KHR: Self = Self(0b1_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl ShaderStageFlags {
-    pub const ANY_HIT_KHR: Self = Self(0b10_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl ShaderStageFlags {
-    pub const CLOSEST_HIT_KHR: Self = Self(0b100_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl ShaderStageFlags {
-    pub const MISS_KHR: Self = Self(0b1000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl ShaderStageFlags {
-    pub const INTERSECTION_KHR: Self = Self(0b1_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl ShaderStageFlags {
-    pub const CALLABLE_KHR: Self = Self(0b10_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl PipelineStageFlags {
-    pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
 impl BufferUsageFlags {
     pub const SHADER_BINDING_TABLE_KHR: Self = Self(0b100_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
+impl DynamicState {
+    pub const RAY_TRACING_PIPELINE_STACK_SIZE_KHR: Self = Self(1_000_347_000);
+}
+#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
 impl PipelineBindPoint {
     pub const RAY_TRACING_KHR: Self = Self(1_000_165_000);
 }
 #[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
 impl PipelineCreateFlags {
     pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR: Self = Self(0b100_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl PipelineCreateFlags {
     pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR: Self = Self(0b1000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl PipelineCreateFlags {
     pub const RAY_TRACING_NO_NULL_MISS_SHADERS_KHR: Self = Self(0b1_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl PipelineCreateFlags {
     pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR: Self = Self(0b10_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl PipelineCreateFlags {
     pub const RAY_TRACING_SKIP_TRIANGLES_KHR: Self = Self(0b1_0000_0000_0000);
+    pub const RAY_TRACING_SKIP_AABBS_KHR: Self = Self(0b10_0000_0000_0000);
+    pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR: Self =
+        Self(0b1000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl PipelineCreateFlags {
-    pub const RAY_TRACING_SKIP_AABBS_KHR: Self = Self(0b10_0000_0000_0000);
+impl PipelineStageFlags {
+    pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl PipelineCreateFlags {
-    pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR: Self =
-        Self(0b1000_0000_0000_0000_0000);
+impl ShaderStageFlags {
+    pub const RAYGEN_KHR: Self = Self(0b1_0000_0000);
+    pub const ANY_HIT_KHR: Self = Self(0b10_0000_0000);
+    pub const CLOSEST_HIT_KHR: Self = Self(0b100_0000_0000);
+    pub const MISS_KHR: Self = Self(0b1000_0000_0000);
+    pub const INTERSECTION_KHR: Self = Self(0b1_0000_0000_0000);
+    pub const CALLABLE_KHR: Self = Self(0b10_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
-impl DynamicState {
-    pub const RAY_TRACING_PIPELINE_STACK_SIZE_KHR: Self = Self(1_000_347_000);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: Self = Self(1_000_347_000);
+    pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: Self = Self(1_000_347_001);
+    pub const RAY_TRACING_PIPELINE_CREATE_INFO_KHR: Self = Self(1_000_150_015);
+    pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: Self = Self(1_000_150_016);
+    pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: Self = Self(1_000_150_018);
 }
 impl KhrRayQueryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_ray_query\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_query\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -12479,7 +9660,7 @@ impl KhrRayQueryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrRayQueryFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_ray_query'"]
@@ -12487,9 +9668,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: Self = Self(1_000_348_013);
 }
 impl NvExtension152Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_152\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_152\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -12502,13 +9683,15 @@ impl NvExtension152Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension152Fn {}
+        Self {}
     }
 }
 impl NvFramebufferMixedSamplesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_framebuffer_mixed_samples\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_framebuffer_mixed_samples\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -12521,7 +9704,7 @@ impl NvFramebufferMixedSamplesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvFramebufferMixedSamplesFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_framebuffer_mixed_samples'"]
@@ -12529,9 +9712,9 @@ impl StructureType {
     pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = Self(1_000_152_000);
 }
 impl NvFillRectangleFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_fill_rectangle\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fill_rectangle\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -12544,7 +9727,7 @@ impl NvFillRectangleFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvFillRectangleFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_fill_rectangle'"]
@@ -12552,9 +9735,9 @@ impl PolygonMode {
     pub const FILL_RECTANGLE_NV: Self = Self(1_000_153_000);
 }
 impl NvShaderSmBuiltinsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shader_sm_builtins\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_sm_builtins\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -12567,21 +9750,18 @@ impl NvShaderSmBuiltinsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvShaderSmBuiltinsFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_shader_sm_builtins'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: Self = Self(1_000_154_000);
-}
-#[doc = "Generated from 'VK_NV_shader_sm_builtins'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: Self = Self(1_000_154_001);
 }
 impl ExtPostDepthCoverageFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_post_depth_coverage\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_post_depth_coverage\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -12594,13 +9774,15 @@ impl ExtPostDepthCoverageFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtPostDepthCoverageFn {}
+        Self {}
     }
 }
 impl KhrSamplerYcbcrConversionFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_sampler_ycbcr_conversion\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_sampler_ycbcr_conversion\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 14u32;
 }
@@ -12629,7 +9811,7 @@ impl KhrSamplerYcbcrConversionFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSamplerYcbcrConversionFn {
+        Self {
             create_sampler_ycbcr_conversion_khr: unsafe {
                 unsafe extern "system" fn create_sampler_ycbcr_conversion_khr(
                     _device: Device,
@@ -12675,307 +9857,127 @@ impl KhrSamplerYcbcrConversionFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSamplerYcbcrConversionKHR.html>"]
-    pub unsafe fn create_sampler_ycbcr_conversion_khr(
-        &self,
-        device: Device,
-        p_create_info: *const SamplerYcbcrConversionCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_ycbcr_conversion: *mut SamplerYcbcrConversion,
-    ) -> Result {
-        (self.create_sampler_ycbcr_conversion_khr)(
-            device,
-            p_create_info,
-            p_allocator,
-            p_ycbcr_conversion,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySamplerYcbcrConversionKHR.html>"]
-    pub unsafe fn destroy_sampler_ycbcr_conversion_khr(
-        &self,
-        device: Device,
-        ycbcr_conversion: SamplerYcbcrConversion,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_sampler_ycbcr_conversion_khr)(device, ycbcr_conversion, p_allocator)
-    }
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl StructureType {
-    pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: Self =
-        Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl StructureType {
-    pub const SAMPLER_YCBCR_CONVERSION_INFO_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION_INFO;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl StructureType {
-    pub const BIND_IMAGE_PLANE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_PLANE_MEMORY_INFO;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl StructureType {
-    pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: Self =
-        Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: Self =
-        Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl StructureType {
-    pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: Self =
-        Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
+impl ChromaLocation {
+    pub const COSITED_EVEN_KHR: Self = Self::COSITED_EVEN;
+    pub const MIDPOINT_KHR: Self = Self::MIDPOINT;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
 impl DebugReportObjectTypeEXT {
     pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl ObjectType {
-    pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
 impl Format {
     pub const G8B8G8R8_422_UNORM_KHR: Self = Self::G8B8G8R8_422_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const B8G8R8G8_422_UNORM_KHR: Self = Self::B8G8R8G8_422_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G8_B8_R8_3PLANE_420_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_420_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G8_B8R8_2PLANE_420_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_420_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G8_B8_R8_3PLANE_422_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_422_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G8_B8R8_2PLANE_422_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_422_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G8_B8_R8_3PLANE_444_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_444_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const R10X6_UNORM_PACK16_KHR: Self = Self::R10X6_UNORM_PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const R10X6G10X6_UNORM_2PACK16_KHR: Self = Self::R10X6G10X6_UNORM_2PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: Self =
         Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: Self =
         Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: Self =
         Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: Self =
         Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: Self =
         Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: Self =
         Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: Self =
         Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: Self =
         Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const R12X4_UNORM_PACK16_KHR: Self = Self::R12X4_UNORM_PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const R12X4G12X4_UNORM_2PACK16_KHR: Self = Self::R12X4G12X4_UNORM_2PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: Self =
         Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: Self =
         Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: Self =
         Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: Self =
         Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: Self =
         Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: Self =
         Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: Self =
         Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: Self =
         Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G16B16G16R16_422_UNORM_KHR: Self = Self::G16B16G16R16_422_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const B16G16R16G16_422_UNORM_KHR: Self = Self::B16G16R16G16_422_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G16_B16_R16_3PLANE_420_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_420_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G16_B16R16_2PLANE_420_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_420_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G16_B16_R16_3PLANE_422_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_422_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G16_B16R16_2PLANE_422_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_422_UNORM;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl Format {
     pub const G16_B16_R16_3PLANE_444_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_444_UNORM;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl ImageAspectFlags {
-    pub const PLANE_0_KHR: Self = Self::PLANE_0;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl ImageAspectFlags {
-    pub const PLANE_1_KHR: Self = Self::PLANE_1;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl ImageAspectFlags {
-    pub const PLANE_2_KHR: Self = Self::PLANE_2;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl ImageCreateFlags {
-    pub const DISJOINT_KHR: Self = Self::DISJOINT;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
 impl FormatFeatureFlags {
     pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = Self::MIDPOINT_CHROMA_SAMPLES;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl FormatFeatureFlags {
     pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self =
         Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl FormatFeatureFlags {
     pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self =
         Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl FormatFeatureFlags {
     pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self =
         Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl FormatFeatureFlags {
     pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self =
         Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl FormatFeatureFlags {
     pub const DISJOINT_KHR: Self = Self::DISJOINT;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl FormatFeatureFlags {
     pub const COSITED_CHROMA_SAMPLES_KHR: Self = Self::COSITED_CHROMA_SAMPLES;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl SamplerYcbcrModelConversion {
-    pub const RGB_IDENTITY_KHR: Self = Self::RGB_IDENTITY;
+impl ImageAspectFlags {
+    pub const PLANE_0_KHR: Self = Self::PLANE_0;
+    pub const PLANE_1_KHR: Self = Self::PLANE_1;
+    pub const PLANE_2_KHR: Self = Self::PLANE_2;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl SamplerYcbcrModelConversion {
-    pub const YCBCR_IDENTITY_KHR: Self = Self::YCBCR_IDENTITY;
+impl ImageCreateFlags {
+    pub const DISJOINT_KHR: Self = Self::DISJOINT;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl SamplerYcbcrModelConversion {
-    pub const YCBCR_709_KHR: Self = Self::YCBCR_709;
+impl ObjectType {
+    pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
 impl SamplerYcbcrModelConversion {
+    pub const RGB_IDENTITY_KHR: Self = Self::RGB_IDENTITY;
+    pub const YCBCR_IDENTITY_KHR: Self = Self::YCBCR_IDENTITY;
+    pub const YCBCR_709_KHR: Self = Self::YCBCR_709;
     pub const YCBCR_601_KHR: Self = Self::YCBCR_601;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl SamplerYcbcrModelConversion {
     pub const YCBCR_2020_KHR: Self = Self::YCBCR_2020;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
 impl SamplerYcbcrRange {
     pub const ITU_FULL_KHR: Self = Self::ITU_FULL;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl SamplerYcbcrRange {
     pub const ITU_NARROW_KHR: Self = Self::ITU_NARROW;
 }
 #[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl ChromaLocation {
-    pub const COSITED_EVEN_KHR: Self = Self::COSITED_EVEN;
-}
-#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
-impl ChromaLocation {
-    pub const MIDPOINT_KHR: Self = Self::MIDPOINT;
+impl StructureType {
+    pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: Self =
+        Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
+    pub const SAMPLER_YCBCR_CONVERSION_INFO_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION_INFO;
+    pub const BIND_IMAGE_PLANE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_PLANE_MEMORY_INFO;
+    pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: Self =
+        Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
+    pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
+    pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: Self =
+        Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
 }
 impl KhrBindMemory2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_bind_memory2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_bind_memory2\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -13003,7 +10005,7 @@ impl KhrBindMemory2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrBindMemory2Fn {
+        Self {
             bind_buffer_memory2_khr: unsafe {
                 unsafe extern "system" fn bind_buffer_memory2_khr(
                     _device: Device,
@@ -13046,43 +10048,24 @@ impl KhrBindMemory2Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindBufferMemory2KHR.html>"]
-    pub unsafe fn bind_buffer_memory2_khr(
-        &self,
-        device: Device,
-        bind_info_count: u32,
-        p_bind_infos: *const BindBufferMemoryInfo,
-    ) -> Result {
-        (self.bind_buffer_memory2_khr)(device, bind_info_count, p_bind_infos)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindImageMemory2KHR.html>"]
-    pub unsafe fn bind_image_memory2_khr(
-        &self,
-        device: Device,
-        bind_info_count: u32,
-        p_bind_infos: *const BindImageMemoryInfo,
-    ) -> Result {
-        (self.bind_image_memory2_khr)(device, bind_info_count, p_bind_infos)
-    }
 }
 #[doc = "Generated from 'VK_KHR_bind_memory2'"]
-impl StructureType {
-    pub const BIND_BUFFER_MEMORY_INFO_KHR: Self = Self::BIND_BUFFER_MEMORY_INFO;
+impl ImageCreateFlags {
+    pub const ALIAS_KHR: Self = Self::ALIAS;
 }
 #[doc = "Generated from 'VK_KHR_bind_memory2'"]
 impl StructureType {
+    pub const BIND_BUFFER_MEMORY_INFO_KHR: Self = Self::BIND_BUFFER_MEMORY_INFO;
     pub const BIND_IMAGE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_MEMORY_INFO;
 }
-#[doc = "Generated from 'VK_KHR_bind_memory2'"]
-impl ImageCreateFlags {
-    pub const ALIAS_KHR: Self = Self::ALIAS;
-}
 impl ExtImageDrmFormatModifierFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_image_drm_format_modifier\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_drm_format_modifier\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 1u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn(
@@ -13101,7 +10084,7 @@ impl ExtImageDrmFormatModifierFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtImageDrmFormatModifierFn {
+        Self {
             get_image_drm_format_modifier_properties_ext: unsafe {
                 unsafe extern "system" fn get_image_drm_format_modifier_properties_ext(
                     _device: Device,
@@ -13125,64 +10108,35 @@ impl ExtImageDrmFormatModifierFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html>"]
-    pub unsafe fn get_image_drm_format_modifier_properties_ext(
-        &self,
-        device: Device,
-        image: Image,
-        p_properties: *mut ImageDrmFormatModifierPropertiesEXT,
-    ) -> Result {
-        (self.get_image_drm_format_modifier_properties_ext)(device, image, p_properties)
-    }
 }
 #[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl Result {
-    pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: Self = Self(-1000158000);
+impl ImageAspectFlags {
+    pub const MEMORY_PLANE_0_EXT: Self = Self(0b1000_0000);
+    pub const MEMORY_PLANE_1_EXT: Self = Self(0b1_0000_0000);
+    pub const MEMORY_PLANE_2_EXT: Self = Self(0b10_0000_0000);
+    pub const MEMORY_PLANE_3_EXT: Self = Self(0b100_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl StructureType {
-    pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: Self = Self(1_000_158_000);
+impl ImageTiling {
+    pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1_000_158_000);
 }
 #[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: Self = Self(1_000_158_002);
+impl Result {
+    pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: Self = Self(-1_000_158_000);
 }
 #[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
 impl StructureType {
+    pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: Self = Self(1_000_158_000);
+    pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: Self = Self(1_000_158_002);
     pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: Self = Self(1_000_158_003);
-}
-#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl StructureType {
     pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: Self = Self(1_000_158_004);
-}
-#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl StructureType {
     pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: Self = Self(1_000_158_005);
-}
-#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl ImageTiling {
-    pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1_000_158_000);
-}
-#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl ImageAspectFlags {
-    pub const MEMORY_PLANE_0_EXT: Self = Self(0b1000_0000);
-}
-#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl ImageAspectFlags {
-    pub const MEMORY_PLANE_1_EXT: Self = Self(0b1_0000_0000);
-}
-#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl ImageAspectFlags {
-    pub const MEMORY_PLANE_2_EXT: Self = Self(0b10_0000_0000);
-}
-#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
-impl ImageAspectFlags {
-    pub const MEMORY_PLANE_3_EXT: Self = Self(0b100_0000_0000);
+    pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: Self = Self(1_000_158_006);
 }
 impl ExtExtension160Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_160\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_160\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -13195,13 +10149,13 @@ impl ExtExtension160Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension160Fn {}
+        Self {}
     }
 }
 impl ExtValidationCacheFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_validation_cache\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_cache\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -13246,7 +10200,7 @@ impl ExtValidationCacheFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtValidationCacheFn {
+        Self {
             create_validation_cache_ext: unsafe {
                 unsafe extern "system" fn create_validation_cache_ext(
                     _device: Device,
@@ -13336,62 +10290,20 @@ impl ExtValidationCacheFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateValidationCacheEXT.html>"]
-    pub unsafe fn create_validation_cache_ext(
-        &self,
-        device: Device,
-        p_create_info: *const ValidationCacheCreateInfoEXT,
-        p_allocator: *const AllocationCallbacks,
-        p_validation_cache: *mut ValidationCacheEXT,
-    ) -> Result {
-        (self.create_validation_cache_ext)(device, p_create_info, p_allocator, p_validation_cache)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyValidationCacheEXT.html>"]
-    pub unsafe fn destroy_validation_cache_ext(
-        &self,
-        device: Device,
-        validation_cache: ValidationCacheEXT,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_validation_cache_ext)(device, validation_cache, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMergeValidationCachesEXT.html>"]
-    pub unsafe fn merge_validation_caches_ext(
-        &self,
-        device: Device,
-        dst_cache: ValidationCacheEXT,
-        src_cache_count: u32,
-        p_src_caches: *const ValidationCacheEXT,
-    ) -> Result {
-        (self.merge_validation_caches_ext)(device, dst_cache, src_cache_count, p_src_caches)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetValidationCacheDataEXT.html>"]
-    pub unsafe fn get_validation_cache_data_ext(
-        &self,
-        device: Device,
-        validation_cache: ValidationCacheEXT,
-        p_data_size: *mut usize,
-        p_data: *mut c_void,
-    ) -> Result {
-        (self.get_validation_cache_data_ext)(device, validation_cache, p_data_size, p_data)
-    }
 }
 #[doc = "Generated from 'VK_EXT_validation_cache'"]
-impl StructureType {
-    pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_000);
+impl ObjectType {
+    pub const VALIDATION_CACHE_EXT: Self = Self(1_000_160_000);
 }
 #[doc = "Generated from 'VK_EXT_validation_cache'"]
 impl StructureType {
+    pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_000);
     pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_001);
 }
-#[doc = "Generated from 'VK_EXT_validation_cache'"]
-impl ObjectType {
-    pub const VALIDATION_CACHE_EXT: Self = Self(1_000_160_000);
-}
 impl ExtDescriptorIndexingFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_descriptor_indexing\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_indexing\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -13404,48 +10316,14 @@ impl ExtDescriptorIndexingFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDescriptorIndexingFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
-impl StructureType {
-    pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self =
-        Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self =
-        Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
-}
-#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self =
-        Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
-}
-#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
-impl StructureType {
-    pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self =
-        Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
-}
-#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
-impl StructureType {
-    pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self =
-        Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
-}
-#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
 impl DescriptorBindingFlags {
     pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND;
-}
-#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
-impl DescriptorBindingFlags {
     pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = Self::UPDATE_UNUSED_WHILE_PENDING;
-}
-#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
-impl DescriptorBindingFlags {
     pub const PARTIALLY_BOUND_EXT: Self = Self::PARTIALLY_BOUND;
-}
-#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
-impl DescriptorBindingFlags {
     pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = Self::VARIABLE_DESCRIPTOR_COUNT;
 }
 #[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
@@ -13460,10 +10338,25 @@ impl DescriptorSetLayoutCreateFlags {
 impl Result {
     pub const ERROR_FRAGMENTATION_EXT: Self = Self::ERROR_FRAGMENTATION;
 }
+#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
+impl StructureType {
+    pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self =
+        Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
+    pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self =
+        Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
+    pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self =
+        Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
+    pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self =
+        Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
+    pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self =
+        Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
+}
 impl ExtShaderViewportIndexLayerFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_viewport_index_layer\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_viewport_index_layer\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -13476,13 +10369,13 @@ impl ExtShaderViewportIndexLayerFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtShaderViewportIndexLayerFn {}
+        Self {}
     }
 }
 impl KhrPortabilitySubsetFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_portability_subset\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_subset\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -13495,21 +10388,18 @@ impl KhrPortabilitySubsetFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrPortabilitySubsetFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_portability_subset'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: Self = Self(1_000_163_000);
-}
-#[doc = "Generated from 'VK_KHR_portability_subset'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: Self = Self(1_000_163_001);
 }
 impl NvShadingRateImageFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shading_rate_image\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shading_rate_image\0") }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -13546,7 +10436,7 @@ impl NvShadingRateImageFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvShadingRateImageFn {
+        Self {
             cmd_bind_shading_rate_image_nv: unsafe {
                 unsafe extern "system" fn cmd_bind_shading_rate_image_nv(
                     _command_buffer: CommandBuffer,
@@ -13614,69 +10504,19 @@ impl NvShadingRateImageFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindShadingRateImageNV.html>"]
-    pub unsafe fn cmd_bind_shading_rate_image_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        image_view: ImageView,
-        image_layout: ImageLayout,
-    ) {
-        (self.cmd_bind_shading_rate_image_nv)(command_buffer, image_view, image_layout)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetViewportShadingRatePaletteNV.html>"]
-    pub unsafe fn cmd_set_viewport_shading_rate_palette_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        first_viewport: u32,
-        viewport_count: u32,
-        p_shading_rate_palettes: *const ShadingRatePaletteNV,
-    ) {
-        (self.cmd_set_viewport_shading_rate_palette_nv)(
-            command_buffer,
-            first_viewport,
-            viewport_count,
-            p_shading_rate_palettes,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetCoarseSampleOrderNV.html>"]
-    pub unsafe fn cmd_set_coarse_sample_order_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        sample_order_type: CoarseSampleOrderTypeNV,
-        custom_sample_order_count: u32,
-        p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
-    ) {
-        (self.cmd_set_coarse_sample_order_nv)(
-            command_buffer,
-            sample_order_type,
-            custom_sample_order_count,
-            p_custom_sample_orders,
-        )
-    }
-}
-#[doc = "Generated from 'VK_NV_shading_rate_image'"]
-impl StructureType {
-    pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: Self = Self(1_000_164_000);
 }
 #[doc = "Generated from 'VK_NV_shading_rate_image'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: Self = Self(1_000_164_001);
-}
-#[doc = "Generated from 'VK_NV_shading_rate_image'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: Self = Self(1_000_164_002);
-}
-#[doc = "Generated from 'VK_NV_shading_rate_image'"]
-impl ImageLayout {
-    pub const SHADING_RATE_OPTIMAL_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
+impl AccessFlags {
+    pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR;
 }
 #[doc = "Generated from 'VK_NV_shading_rate_image'"]
 impl DynamicState {
     pub const VIEWPORT_SHADING_RATE_PALETTE_NV: Self = Self(1_000_164_004);
+    pub const VIEWPORT_COARSE_SAMPLE_ORDER_NV: Self = Self(1_000_164_006);
 }
 #[doc = "Generated from 'VK_NV_shading_rate_image'"]
-impl AccessFlags {
-    pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR;
+impl ImageLayout {
+    pub const SHADING_RATE_OPTIMAL_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
 }
 #[doc = "Generated from 'VK_NV_shading_rate_image'"]
 impl ImageUsageFlags {
@@ -13688,17 +10528,16 @@ impl PipelineStageFlags {
 }
 #[doc = "Generated from 'VK_NV_shading_rate_image'"]
 impl StructureType {
+    pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: Self = Self(1_000_164_000);
+    pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: Self = Self(1_000_164_001);
+    pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: Self = Self(1_000_164_002);
     pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: Self =
         Self(1_000_164_005);
 }
-#[doc = "Generated from 'VK_NV_shading_rate_image'"]
-impl DynamicState {
-    pub const VIEWPORT_COARSE_SAMPLE_ORDER_NV: Self = Self(1_000_164_006);
-}
 impl NvRayTracingFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_ray_tracing\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing\0") }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -13817,7 +10656,7 @@ impl NvRayTracingFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvRayTracingFn {
+        Self {
             create_acceleration_structure_nv: unsafe {
                 unsafe extern "system" fn create_acceleration_structure_nv(
                     _device: Device,
@@ -14093,406 +10932,119 @@ impl NvRayTracingFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateAccelerationStructureNV.html>"]
-    pub unsafe fn create_acceleration_structure_nv(
-        &self,
-        device: Device,
-        p_create_info: *const AccelerationStructureCreateInfoNV,
-        p_allocator: *const AllocationCallbacks,
-        p_acceleration_structure: *mut AccelerationStructureNV,
-    ) -> Result {
-        (self.create_acceleration_structure_nv)(
-            device,
-            p_create_info,
-            p_allocator,
-            p_acceleration_structure,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyAccelerationStructureNV.html>"]
-    pub unsafe fn destroy_acceleration_structure_nv(
-        &self,
-        device: Device,
-        acceleration_structure: AccelerationStructureNV,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_acceleration_structure_nv)(device, acceleration_structure, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html>"]
-    pub unsafe fn get_acceleration_structure_memory_requirements_nv(
-        &self,
-        device: Device,
-        p_info: *const AccelerationStructureMemoryRequirementsInfoNV,
-        p_memory_requirements: *mut MemoryRequirements2KHR,
-    ) {
-        (self.get_acceleration_structure_memory_requirements_nv)(
-            device,
-            p_info,
-            p_memory_requirements,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindAccelerationStructureMemoryNV.html>"]
-    pub unsafe fn bind_acceleration_structure_memory_nv(
-        &self,
-        device: Device,
-        bind_info_count: u32,
-        p_bind_infos: *const BindAccelerationStructureMemoryInfoNV,
-    ) -> Result {
-        (self.bind_acceleration_structure_memory_nv)(device, bind_info_count, p_bind_infos)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBuildAccelerationStructureNV.html>"]
-    pub unsafe fn cmd_build_acceleration_structure_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        p_info: *const AccelerationStructureInfoNV,
-        instance_data: Buffer,
-        instance_offset: DeviceSize,
-        update: Bool32,
-        dst: AccelerationStructureNV,
-        src: AccelerationStructureNV,
-        scratch: Buffer,
-        scratch_offset: DeviceSize,
-    ) {
-        (self.cmd_build_acceleration_structure_nv)(
-            command_buffer,
-            p_info,
-            instance_data,
-            instance_offset,
-            update,
-            dst,
-            src,
-            scratch,
-            scratch_offset,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyAccelerationStructureNV.html>"]
-    pub unsafe fn cmd_copy_acceleration_structure_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        dst: AccelerationStructureNV,
-        src: AccelerationStructureNV,
-        mode: CopyAccelerationStructureModeKHR,
-    ) {
-        (self.cmd_copy_acceleration_structure_nv)(command_buffer, dst, src, mode)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdTraceRaysNV.html>"]
-    pub unsafe fn cmd_trace_rays_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        raygen_shader_binding_table_buffer: Buffer,
-        raygen_shader_binding_offset: DeviceSize,
-        miss_shader_binding_table_buffer: Buffer,
-        miss_shader_binding_offset: DeviceSize,
-        miss_shader_binding_stride: DeviceSize,
-        hit_shader_binding_table_buffer: Buffer,
-        hit_shader_binding_offset: DeviceSize,
-        hit_shader_binding_stride: DeviceSize,
-        callable_shader_binding_table_buffer: Buffer,
-        callable_shader_binding_offset: DeviceSize,
-        callable_shader_binding_stride: DeviceSize,
-        width: u32,
-        height: u32,
-        depth: u32,
-    ) {
-        (self.cmd_trace_rays_nv)(
-            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,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRayTracingPipelinesNV.html>"]
-    pub unsafe fn create_ray_tracing_pipelines_nv(
-        &self,
-        device: Device,
-        pipeline_cache: PipelineCache,
-        create_info_count: u32,
-        p_create_infos: *const RayTracingPipelineCreateInfoNV,
-        p_allocator: *const AllocationCallbacks,
-        p_pipelines: *mut Pipeline,
-    ) -> Result {
-        (self.create_ray_tracing_pipelines_nv)(
-            device,
-            pipeline_cache,
-            create_info_count,
-            p_create_infos,
-            p_allocator,
-            p_pipelines,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRayTracingShaderGroupHandlesNV.html>"]
-    pub unsafe fn get_ray_tracing_shader_group_handles_nv(
-        &self,
-        device: Device,
-        pipeline: Pipeline,
-        first_group: u32,
-        group_count: u32,
-        data_size: usize,
-        p_data: *mut c_void,
-    ) -> Result {
-        (self.get_ray_tracing_shader_group_handles_nv)(
-            device,
-            pipeline,
-            first_group,
-            group_count,
-            data_size,
-            p_data,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetAccelerationStructureHandleNV.html>"]
-    pub unsafe fn get_acceleration_structure_handle_nv(
-        &self,
-        device: Device,
-        acceleration_structure: AccelerationStructureNV,
-        data_size: usize,
-        p_data: *mut c_void,
-    ) -> Result {
-        (self.get_acceleration_structure_handle_nv)(
-            device,
-            acceleration_structure,
-            data_size,
-            p_data,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html>"]
-    pub unsafe fn cmd_write_acceleration_structures_properties_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        acceleration_structure_count: u32,
-        p_acceleration_structures: *const AccelerationStructureNV,
-        query_type: QueryType,
-        query_pool: QueryPool,
-        first_query: u32,
-    ) {
-        (self.cmd_write_acceleration_structures_properties_nv)(
-            command_buffer,
-            acceleration_structure_count,
-            p_acceleration_structures,
-            query_type,
-            query_pool,
-            first_query,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCompileDeferredNV.html>"]
-    pub unsafe fn compile_deferred_nv(
-        &self,
-        device: Device,
-        pipeline: Pipeline,
-        shader: u32,
-    ) -> Result {
-        (self.compile_deferred_nv)(device, pipeline, shader)
-    }
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const RAY_TRACING_PIPELINE_CREATE_INFO_NV: Self = Self(1_000_165_000);
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self = Self(1_000_165_001);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const GEOMETRY_NV: Self = Self(1_000_165_003);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const GEOMETRY_TRIANGLES_NV: Self = Self(1_000_165_004);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const GEOMETRY_AABB_NV: Self = Self(1_000_165_005);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: Self = Self(1_000_165_006);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_007);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_165_008);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: Self = Self(1_000_165_009);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_165_011);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1_000_165_012);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl ShaderStageFlags {
-    pub const RAYGEN_NV: Self = Self::RAYGEN_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl ShaderStageFlags {
-    pub const ANY_HIT_NV: Self = Self::ANY_HIT_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl ShaderStageFlags {
-    pub const CLOSEST_HIT_NV: Self = Self::CLOSEST_HIT_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl ShaderStageFlags {
-    pub const MISS_NV: Self = Self::MISS_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl ShaderStageFlags {
-    pub const INTERSECTION_NV: Self = Self::INTERSECTION_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl ShaderStageFlags {
-    pub const CALLABLE_NV: Self = Self::CALLABLE_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl PipelineStageFlags {
-    pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl PipelineStageFlags {
-    pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl BufferUsageFlags {
-    pub const RAY_TRACING_NV: Self = Self::SHADER_BINDING_TABLE_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl PipelineBindPoint {
-    pub const RAY_TRACING_NV: Self = Self::RAY_TRACING_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl DescriptorType {
-    pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
+impl AccelerationStructureTypeKHR {
+    pub const TOP_LEVEL_NV: Self = Self::TOP_LEVEL;
+    pub const BOTTOM_LEVEL_NV: Self = Self::BOTTOM_LEVEL;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
 impl AccessFlags {
     pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl AccessFlags {
     pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl QueryType {
-    pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: Self = Self(1_000_165_000);
+impl BufferUsageFlags {
+    pub const RAY_TRACING_NV: Self = Self::SHADER_BINDING_TABLE_KHR;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl PipelineCreateFlags {
-    pub const DEFER_COMPILE_NV: Self = Self(0b10_0000);
+impl BuildAccelerationStructureFlagsKHR {
+    pub const ALLOW_UPDATE_NV: Self = Self::ALLOW_UPDATE;
+    pub const ALLOW_COMPACTION_NV: Self = Self::ALLOW_COMPACTION;
+    pub const PREFER_FAST_TRACE_NV: Self = Self::PREFER_FAST_TRACE;
+    pub const PREFER_FAST_BUILD_NV: Self = Self::PREFER_FAST_BUILD;
+    pub const LOW_MEMORY_NV: Self = Self::LOW_MEMORY;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl ObjectType {
-    pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
+impl CopyAccelerationStructureModeKHR {
+    pub const CLONE_NV: Self = Self::CLONE;
+    pub const COMPACT_NV: Self = Self::COMPACT;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
 impl DebugReportObjectTypeEXT {
     pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl IndexType {
-    pub const NONE_NV: Self = Self::NONE_KHR;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl RayTracingShaderGroupTypeKHR {
-    pub const GENERAL_NV: Self = Self::GENERAL;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl RayTracingShaderGroupTypeKHR {
-    pub const TRIANGLES_HIT_GROUP_NV: Self = Self::TRIANGLES_HIT_GROUP;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl RayTracingShaderGroupTypeKHR {
-    pub const PROCEDURAL_HIT_GROUP_NV: Self = Self::PROCEDURAL_HIT_GROUP;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl GeometryTypeKHR {
-    pub const TRIANGLES_NV: Self = Self::TRIANGLES;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl GeometryTypeKHR {
-    pub const AABBS_NV: Self = Self::AABBS;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl AccelerationStructureTypeKHR {
-    pub const TOP_LEVEL_NV: Self = Self::TOP_LEVEL;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl AccelerationStructureTypeKHR {
-    pub const BOTTOM_LEVEL_NV: Self = Self::BOTTOM_LEVEL;
+impl DescriptorType {
+    pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
 impl GeometryFlagsKHR {
     pub const OPAQUE_NV: Self = Self::OPAQUE;
-}
-#[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl GeometryFlagsKHR {
     pub const NO_DUPLICATE_ANY_HIT_INVOCATION_NV: Self = Self::NO_DUPLICATE_ANY_HIT_INVOCATION;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
 impl GeometryInstanceFlagsKHR {
     pub const TRIANGLE_CULL_DISABLE_NV: Self = Self::TRIANGLE_FACING_CULL_DISABLE;
+    pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_NV: Self = Self::TRIANGLE_FRONT_COUNTERCLOCKWISE;
+    pub const FORCE_OPAQUE_NV: Self = Self::FORCE_OPAQUE;
+    pub const FORCE_NO_OPAQUE_NV: Self = Self::FORCE_NO_OPAQUE;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl GeometryInstanceFlagsKHR {
-    pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_NV: Self = Self::TRIANGLE_FRONT_COUNTERCLOCKWISE;
+impl GeometryTypeKHR {
+    pub const TRIANGLES_NV: Self = Self::TRIANGLES;
+    pub const AABBS_NV: Self = Self::AABBS;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl GeometryInstanceFlagsKHR {
-    pub const FORCE_OPAQUE_NV: Self = Self::FORCE_OPAQUE;
+impl IndexType {
+    pub const NONE_NV: Self = Self::NONE_KHR;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl GeometryInstanceFlagsKHR {
-    pub const FORCE_NO_OPAQUE_NV: Self = Self::FORCE_NO_OPAQUE;
+impl ObjectType {
+    pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl BuildAccelerationStructureFlagsKHR {
-    pub const ALLOW_UPDATE_NV: Self = Self::ALLOW_UPDATE;
+impl PipelineBindPoint {
+    pub const RAY_TRACING_NV: Self = Self::RAY_TRACING_KHR;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl BuildAccelerationStructureFlagsKHR {
-    pub const ALLOW_COMPACTION_NV: Self = Self::ALLOW_COMPACTION;
+impl PipelineCreateFlags {
+    pub const DEFER_COMPILE_NV: Self = Self(0b10_0000);
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl BuildAccelerationStructureFlagsKHR {
-    pub const PREFER_FAST_TRACE_NV: Self = Self::PREFER_FAST_TRACE;
+impl PipelineStageFlags {
+    pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR;
+    pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl BuildAccelerationStructureFlagsKHR {
-    pub const PREFER_FAST_BUILD_NV: Self = Self::PREFER_FAST_BUILD;
+impl QueryType {
+    pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: Self = Self(1_000_165_000);
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl BuildAccelerationStructureFlagsKHR {
-    pub const LOW_MEMORY_NV: Self = Self::LOW_MEMORY;
+impl RayTracingShaderGroupTypeKHR {
+    pub const GENERAL_NV: Self = Self::GENERAL;
+    pub const TRIANGLES_HIT_GROUP_NV: Self = Self::TRIANGLES_HIT_GROUP;
+    pub const PROCEDURAL_HIT_GROUP_NV: Self = Self::PROCEDURAL_HIT_GROUP;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl CopyAccelerationStructureModeKHR {
-    pub const CLONE_NV: Self = Self::CLONE;
+impl ShaderStageFlags {
+    pub const RAYGEN_NV: Self = Self::RAYGEN_KHR;
+    pub const ANY_HIT_NV: Self = Self::ANY_HIT_KHR;
+    pub const CLOSEST_HIT_NV: Self = Self::CLOSEST_HIT_KHR;
+    pub const MISS_NV: Self = Self::MISS_KHR;
+    pub const INTERSECTION_NV: Self = Self::INTERSECTION_KHR;
+    pub const CALLABLE_NV: Self = Self::CALLABLE_KHR;
 }
 #[doc = "Generated from 'VK_NV_ray_tracing'"]
-impl CopyAccelerationStructureModeKHR {
-    pub const COMPACT_NV: Self = Self::COMPACT;
+impl StructureType {
+    pub const RAY_TRACING_PIPELINE_CREATE_INFO_NV: Self = Self(1_000_165_000);
+    pub const ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self = Self(1_000_165_001);
+    pub const GEOMETRY_NV: Self = Self(1_000_165_003);
+    pub const GEOMETRY_TRIANGLES_NV: Self = Self(1_000_165_004);
+    pub const GEOMETRY_AABB_NV: Self = Self(1_000_165_005);
+    pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: Self = Self(1_000_165_006);
+    pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_007);
+    pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_165_008);
+    pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: Self = Self(1_000_165_009);
+    pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_165_011);
+    pub const ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1_000_165_012);
 }
 impl NvRepresentativeFragmentTestFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_representative_fragment_test\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_representative_fragment_test\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -14505,22 +11057,19 @@ impl NvRepresentativeFragmentTestFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvRepresentativeFragmentTestFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_representative_fragment_test'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: Self = Self(1_000_166_000);
-}
-#[doc = "Generated from 'VK_NV_representative_fragment_test'"]
-impl StructureType {
     pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: Self =
         Self(1_000_166_001);
 }
 impl NvExtension168Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_168\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_168\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -14533,13 +11082,13 @@ impl NvExtension168Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension168Fn {}
+        Self {}
     }
 }
 impl KhrMaintenance3Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_maintenance3\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance3\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -14560,7 +11109,7 @@ impl KhrMaintenance3Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrMaintenance3Fn {
+        Self {
             get_descriptor_set_layout_support_khr: unsafe {
                 unsafe extern "system" fn get_descriptor_set_layout_support_khr(
                     _device: Device,
@@ -14584,29 +11133,17 @@ impl KhrMaintenance3Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDescriptorSetLayoutSupportKHR.html>"]
-    pub unsafe fn get_descriptor_set_layout_support_khr(
-        &self,
-        device: Device,
-        p_create_info: *const DescriptorSetLayoutCreateInfo,
-        p_support: *mut DescriptorSetLayoutSupport,
-    ) {
-        (self.get_descriptor_set_layout_support_khr)(device, p_create_info, p_support)
-    }
 }
 #[doc = "Generated from 'VK_KHR_maintenance3'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: Self =
         Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
-}
-#[doc = "Generated from 'VK_KHR_maintenance3'"]
-impl StructureType {
     pub const DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: Self = Self::DESCRIPTOR_SET_LAYOUT_SUPPORT;
 }
 impl KhrDrawIndirectCountFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_draw_indirect_count\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_draw_indirect_count\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -14622,7 +11159,7 @@ impl KhrDrawIndirectCountFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDrawIndirectCountFn {
+        Self {
             cmd_draw_indirect_count_khr: unsafe {
                 unsafe extern "system" fn cmd_draw_indirect_count_khr(
                     _command_buffer: CommandBuffer,
@@ -14674,53 +11211,11 @@ impl KhrDrawIndirectCountFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirectCountKHR.html>"]
-    pub unsafe fn cmd_draw_indirect_count_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        count_buffer: Buffer,
-        count_buffer_offset: DeviceSize,
-        max_draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_indirect_count_khr)(
-            command_buffer,
-            buffer,
-            offset,
-            count_buffer,
-            count_buffer_offset,
-            max_draw_count,
-            stride,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirectCountKHR.html>"]
-    pub unsafe fn cmd_draw_indexed_indirect_count_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        count_buffer: Buffer,
-        count_buffer_offset: DeviceSize,
-        max_draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_indexed_indirect_count_khr)(
-            command_buffer,
-            buffer,
-            offset,
-            count_buffer,
-            count_buffer_offset,
-            max_draw_count,
-            stride,
-        )
-    }
 }
 impl ExtFilterCubicFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_filter_cubic\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_filter_cubic\0") }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -14733,29 +11228,28 @@ impl ExtFilterCubicFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtFilterCubicFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_filter_cubic'"]
 impl Filter {
-    pub const CUBIC_EXT: Self = Self::CUBIC_IMG;
+    pub const CUBIC_EXT: Self = Self(1_000_015_000);
 }
 #[doc = "Generated from 'VK_EXT_filter_cubic'"]
 impl FormatFeatureFlags {
-    pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC_IMG;
+    pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self(0b10_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_filter_cubic'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: Self = Self(1_000_170_000);
-}
-#[doc = "Generated from 'VK_EXT_filter_cubic'"]
-impl StructureType {
     pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: Self = Self(1_000_170_001);
 }
 impl QcomRenderPassShaderResolveFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_render_pass_shader_resolve\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_shader_resolve\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 4u32;
 }
@@ -14768,21 +11262,18 @@ impl QcomRenderPassShaderResolveFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomRenderPassShaderResolveFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_QCOM_render_pass_shader_resolve'"]
 impl SubpassDescriptionFlags {
     pub const FRAGMENT_REGION_QCOM: Self = Self(0b100);
-}
-#[doc = "Generated from 'VK_QCOM_render_pass_shader_resolve'"]
-impl SubpassDescriptionFlags {
     pub const SHADER_RESOLVE_QCOM: Self = Self(0b1000);
 }
 impl QcomExtension173Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_173\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_173\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -14795,7 +11286,7 @@ impl QcomExtension173Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomExtension173Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_QCOM_extension_173'"]
@@ -14805,15 +11296,12 @@ impl BufferUsageFlags {
 #[doc = "Generated from 'VK_QCOM_extension_173'"]
 impl ImageUsageFlags {
     pub const RESERVED_16_QCOM: Self = Self(0b1_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_QCOM_extension_173'"]
-impl ImageUsageFlags {
     pub const RESERVED_17_QCOM: Self = Self(0b10_0000_0000_0000_0000);
 }
 impl QcomExtension174Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_174\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_174\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -14826,13 +11314,13 @@ impl QcomExtension174Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomExtension174Fn {}
+        Self {}
     }
 }
 impl ExtGlobalPriorityFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_global_priority\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -14845,21 +11333,26 @@ impl ExtGlobalPriorityFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtGlobalPriorityFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_global_priority'"]
-impl StructureType {
-    pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self = Self(1_000_174_000);
+impl Result {
+    pub const ERROR_NOT_PERMITTED_EXT: Self = Self::ERROR_NOT_PERMITTED_KHR;
 }
 #[doc = "Generated from 'VK_EXT_global_priority'"]
-impl Result {
-    pub const ERROR_NOT_PERMITTED_EXT: Self = Self(-1000174001);
+impl StructureType {
+    pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self =
+        Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
 }
 impl KhrShaderSubgroupExtendedTypesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_subgroup_extended_types\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_shader_subgroup_extended_types\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -14872,7 +11365,7 @@ impl KhrShaderSubgroupExtendedTypesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderSubgroupExtendedTypesFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_shader_subgroup_extended_types'"]
@@ -14881,9 +11374,9 @@ impl StructureType {
         Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
 }
 impl ExtExtension177Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_177\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_177\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -14896,13 +11389,13 @@ impl ExtExtension177Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension177Fn {}
+        Self {}
     }
 }
 impl Khr8bitStorageFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_8bit_storage\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_8bit_storage\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -14915,7 +11408,7 @@ impl Khr8bitStorageFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        Khr8bitStorageFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_8bit_storage'"]
@@ -14924,9 +11417,9 @@ impl StructureType {
         Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
 }
 impl ExtExternalMemoryHostFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_external_memory_host\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_host\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -14948,7 +11441,7 @@ impl ExtExternalMemoryHostFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExternalMemoryHostFn {
+        Self {
             get_memory_host_pointer_properties_ext: unsafe {
                 unsafe extern "system" fn get_memory_host_pointer_properties_ext(
                     _device: Device,
@@ -14973,46 +11466,22 @@ impl ExtExternalMemoryHostFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryHostPointerPropertiesEXT.html>"]
-    pub unsafe fn get_memory_host_pointer_properties_ext(
-        &self,
-        device: Device,
-        handle_type: ExternalMemoryHandleTypeFlags,
-        p_host_pointer: *const c_void,
-        p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT,
-    ) -> Result {
-        (self.get_memory_host_pointer_properties_ext)(
-            device,
-            handle_type,
-            p_host_pointer,
-            p_memory_host_pointer_properties,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_external_memory_host'"]
-impl StructureType {
-    pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1_000_178_000);
+impl ExternalMemoryHandleTypeFlags {
+    pub const HOST_ALLOCATION_EXT: Self = Self(0b1000_0000);
+    pub const HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = Self(0b1_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_external_memory_host'"]
 impl StructureType {
+    pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1_000_178_000);
     pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = Self(1_000_178_001);
-}
-#[doc = "Generated from 'VK_EXT_external_memory_host'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = Self(1_000_178_002);
 }
-#[doc = "Generated from 'VK_EXT_external_memory_host'"]
-impl ExternalMemoryHandleTypeFlags {
-    pub const HOST_ALLOCATION_EXT: Self = Self(0b1000_0000);
-}
-#[doc = "Generated from 'VK_EXT_external_memory_host'"]
-impl ExternalMemoryHandleTypeFlags {
-    pub const HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = Self(0b1_0000_0000);
-}
 impl AmdBufferMarkerFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_buffer_marker\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_buffer_marker\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15035,7 +11504,7 @@ impl AmdBufferMarkerFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdBufferMarkerFn {
+        Self {
             cmd_write_buffer_marker_amd: unsafe {
                 unsafe extern "system" fn cmd_write_buffer_marker_amd(
                     _command_buffer: CommandBuffer,
@@ -15060,28 +11529,11 @@ impl AmdBufferMarkerFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteBufferMarkerAMD.html>"]
-    pub unsafe fn cmd_write_buffer_marker_amd(
-        &self,
-        command_buffer: CommandBuffer,
-        pipeline_stage: PipelineStageFlags,
-        dst_buffer: Buffer,
-        dst_offset: DeviceSize,
-        marker: u32,
-    ) {
-        (self.cmd_write_buffer_marker_amd)(
-            command_buffer,
-            pipeline_stage,
-            dst_buffer,
-            dst_offset,
-            marker,
-        )
-    }
 }
 impl KhrShaderAtomicInt64Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_atomic_int64\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_atomic_int64\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15094,7 +11546,7 @@ impl KhrShaderAtomicInt64Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderAtomicInt64Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_shader_atomic_int64'"]
@@ -15103,9 +11555,9 @@ impl StructureType {
         Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
 }
 impl KhrShaderClockFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_clock\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_clock\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15118,7 +11570,7 @@ impl KhrShaderClockFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderClockFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_shader_clock'"]
@@ -15126,9 +11578,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: Self = Self(1_000_181_000);
 }
 impl AmdExtension183Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_183\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_183\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -15141,13 +11593,15 @@ impl AmdExtension183Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension183Fn {}
+        Self {}
     }
 }
 impl AmdPipelineCompilerControlFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_pipeline_compiler_control\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_pipeline_compiler_control\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15160,7 +11614,7 @@ impl AmdPipelineCompilerControlFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdPipelineCompilerControlFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_AMD_pipeline_compiler_control'"]
@@ -15168,9 +11622,11 @@ impl StructureType {
     pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: Self = Self(1_000_183_000);
 }
 impl ExtCalibratedTimestampsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_calibrated_timestamps\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_calibrated_timestamps\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -15201,7 +11657,7 @@ impl ExtCalibratedTimestampsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtCalibratedTimestampsFn {
+        Self {
             get_physical_device_calibrateable_time_domains_ext: unsafe {
                 unsafe extern "system" fn get_physical_device_calibrateable_time_domains_ext(
                     _physical_device: PhysicalDevice,
@@ -15248,45 +11704,17 @@ impl ExtCalibratedTimestampsFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html>"]
-    pub unsafe fn get_physical_device_calibrateable_time_domains_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        p_time_domain_count: *mut u32,
-        p_time_domains: *mut TimeDomainEXT,
-    ) -> Result {
-        (self.get_physical_device_calibrateable_time_domains_ext)(
-            physical_device,
-            p_time_domain_count,
-            p_time_domains,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetCalibratedTimestampsEXT.html>"]
-    pub unsafe fn get_calibrated_timestamps_ext(
-        &self,
-        device: Device,
-        timestamp_count: u32,
-        p_timestamp_infos: *const CalibratedTimestampInfoEXT,
-        p_timestamps: *mut u64,
-        p_max_deviation: *mut u64,
-    ) -> Result {
-        (self.get_calibrated_timestamps_ext)(
-            device,
-            timestamp_count,
-            p_timestamp_infos,
-            p_timestamps,
-            p_max_deviation,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_calibrated_timestamps'"]
 impl StructureType {
     pub const CALIBRATED_TIMESTAMP_INFO_EXT: Self = Self(1_000_184_000);
 }
 impl AmdShaderCorePropertiesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_core_properties\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -15299,7 +11727,7 @@ impl AmdShaderCorePropertiesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdShaderCorePropertiesFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_AMD_shader_core_properties'"]
@@ -15307,9 +11735,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1_000_185_000);
 }
 impl AmdExtension187Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_187\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_187\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -15322,83 +11750,78 @@ impl AmdExtension187Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension187Fn {}
+        Self {}
     }
 }
-impl ExtVideoDecodeH265Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_video_decode_h265\0")
-            .expect("Wrong extension string")
+impl KhrVideoDecodeH265Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h265\0") }
     }
-    pub const SPEC_VERSION: u32 = 1u32;
+    pub const SPEC_VERSION: u32 = 7u32;
 }
 #[derive(Clone)]
-pub struct ExtVideoDecodeH265Fn {}
-unsafe impl Send for ExtVideoDecodeH265Fn {}
-unsafe impl Sync for ExtVideoDecodeH265Fn {}
-impl ExtVideoDecodeH265Fn {
+pub struct KhrVideoDecodeH265Fn {}
+unsafe impl Send for KhrVideoDecodeH265Fn {}
+unsafe impl Sync for KhrVideoDecodeH265Fn {}
+impl KhrVideoDecodeH265Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtVideoDecodeH265Fn {}
+        Self {}
     }
 }
-#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H265_CAPABILITIES_EXT: Self = Self(1_000_187_000);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: Self = Self(1_000_187_001);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
+#[doc = "Generated from 'VK_KHR_video_decode_h265'"]
 impl StructureType {
-    pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_187_002);
+    pub const VIDEO_DECODE_H265_CAPABILITIES_KHR: Self = Self(1_000_187_000);
+    pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_187_001);
+    pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_187_002);
+    pub const VIDEO_DECODE_H265_PROFILE_INFO_KHR: Self = Self(1_000_187_003);
+    pub const VIDEO_DECODE_H265_PICTURE_INFO_KHR: Self = Self(1_000_187_004);
+    pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: Self = Self(1_000_187_005);
 }
-#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_187_003);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H265_PROFILE_EXT: Self = Self(1_000_187_004);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H265_PICTURE_INFO_EXT: Self = Self(1_000_187_005);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
-impl StructureType {
-    pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_187_006);
-}
-#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
+#[doc = "Generated from 'VK_KHR_video_decode_h265'"]
 impl VideoCodecOperationFlagsKHR {
-    pub const DECODE_H265_EXT: Self = Self(0b10);
+    pub const DECODE_H265: Self = Self(0b10);
 }
-impl AmdExtension189Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_189\0")
-            .expect("Wrong extension string")
+impl KhrGlobalPriorityFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_global_priority\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct AmdExtension189Fn {}
-unsafe impl Send for AmdExtension189Fn {}
-unsafe impl Sync for AmdExtension189Fn {}
-impl AmdExtension189Fn {
+pub struct KhrGlobalPriorityFn {}
+unsafe impl Send for KhrGlobalPriorityFn {}
+unsafe impl Sync for KhrGlobalPriorityFn {}
+impl KhrGlobalPriorityFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension189Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_KHR_global_priority'"]
+impl Result {
+    pub const ERROR_NOT_PERMITTED_KHR: Self = Self(-1_000_174_001);
+}
+#[doc = "Generated from 'VK_KHR_global_priority'"]
+impl StructureType {
+    pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: Self = Self(1_000_174_000);
+    pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: Self = Self(1_000_388_000);
+    pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: Self = Self(1_000_388_001);
+}
 impl AmdMemoryOverallocationBehaviorFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_memory_overallocation_behavior\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_AMD_memory_overallocation_behavior\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15411,7 +11834,7 @@ impl AmdMemoryOverallocationBehaviorFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdMemoryOverallocationBehaviorFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_AMD_memory_overallocation_behavior'"]
@@ -15419,9 +11842,11 @@ impl StructureType {
     pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: Self = Self(1_000_189_000);
 }
 impl ExtVertexAttributeDivisorFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_vertex_attribute_divisor\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_attribute_divisor\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -15434,25 +11859,19 @@ impl ExtVertexAttributeDivisorFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtVertexAttributeDivisorFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_vertex_attribute_divisor'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = Self(1_000_190_000);
-}
-#[doc = "Generated from 'VK_EXT_vertex_attribute_divisor'"]
-impl StructureType {
     pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = Self(1_000_190_001);
-}
-#[doc = "Generated from 'VK_EXT_vertex_attribute_divisor'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: Self = Self(1_000_190_002);
 }
 impl GgpFrameTokenFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_frame_token\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_frame_token\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15465,7 +11884,7 @@ impl GgpFrameTokenFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GgpFrameTokenFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_GGP_frame_token'"]
@@ -15473,9 +11892,11 @@ impl StructureType {
     pub const PRESENT_FRAME_TOKEN_GGP: Self = Self(1_000_191_000);
 }
 impl ExtPipelineCreationFeedbackFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pipeline_creation_feedback\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_creation_feedback\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15488,17 +11909,18 @@ impl ExtPipelineCreationFeedbackFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtPipelineCreationFeedbackFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_pipeline_creation_feedback'"]
 impl StructureType {
-    pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_192_000);
+    pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: Self =
+        Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
 }
 impl GoogleExtension194Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_194\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_194\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -15511,13 +11933,13 @@ impl GoogleExtension194Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GoogleExtension194Fn {}
+        Self {}
     }
 }
 impl GoogleExtension195Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_195\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_195\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -15530,36 +11952,13 @@ impl GoogleExtension195Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GoogleExtension195Fn {}
-    }
-}
-impl GoogleExtension196Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_196\0")
-            .expect("Wrong extension string")
-    }
-    pub const SPEC_VERSION: u32 = 0u32;
-}
-#[derive(Clone)]
-pub struct GoogleExtension196Fn {}
-unsafe impl Send for GoogleExtension196Fn {}
-unsafe impl Sync for GoogleExtension196Fn {}
-impl GoogleExtension196Fn {
-    pub fn load<F>(mut _f: F) -> Self
-    where
-        F: FnMut(&::std::ffi::CStr) -> *const c_void,
-    {
-        GoogleExtension196Fn {}
+        Self {}
     }
 }
-#[doc = "Generated from 'VK_GOOGLE_extension_196'"]
-impl PipelineCacheCreateFlags {
-    pub const RESERVED_1_EXT: Self = Self(0b10);
-}
 impl KhrDriverPropertiesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_driver_properties\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_driver_properties\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15572,65 +11971,34 @@ impl KhrDriverPropertiesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDriverPropertiesFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
 impl DriverId {
     pub const AMD_PROPRIETARY_KHR: Self = Self::AMD_PROPRIETARY;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const AMD_OPEN_SOURCE_KHR: Self = Self::AMD_OPEN_SOURCE;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const MESA_RADV_KHR: Self = Self::MESA_RADV;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const NVIDIA_PROPRIETARY_KHR: Self = Self::NVIDIA_PROPRIETARY;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const INTEL_PROPRIETARY_WINDOWS_KHR: Self = Self::INTEL_PROPRIETARY_WINDOWS;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const INTEL_OPEN_SOURCE_MESA_KHR: Self = Self::INTEL_OPEN_SOURCE_MESA;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const IMAGINATION_PROPRIETARY_KHR: Self = Self::IMAGINATION_PROPRIETARY;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const QUALCOMM_PROPRIETARY_KHR: Self = Self::QUALCOMM_PROPRIETARY;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const ARM_PROPRIETARY_KHR: Self = Self::ARM_PROPRIETARY;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const GOOGLE_SWIFTSHADER_KHR: Self = Self::GOOGLE_SWIFTSHADER;
-}
-#[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
     pub const GGP_PROPRIETARY_KHR: Self = Self::GGP_PROPRIETARY;
+    pub const BROADCOM_PROPRIETARY_KHR: Self = Self::BROADCOM_PROPRIETARY;
 }
 #[doc = "Generated from 'VK_KHR_driver_properties'"]
-impl DriverId {
-    pub const BROADCOM_PROPRIETARY_KHR: Self = Self::BROADCOM_PROPRIETARY;
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES;
 }
 impl KhrShaderFloatControlsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_float_controls\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float_controls\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 4u32;
 }
@@ -15643,30 +12011,26 @@ impl KhrShaderFloatControlsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderFloatControlsFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_shader_float_controls'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: Self =
-        Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
-}
-#[doc = "Generated from 'VK_KHR_shader_float_controls'"]
 impl ShaderFloatControlsIndependence {
     pub const TYPE_32_ONLY_KHR: Self = Self::TYPE_32_ONLY;
-}
-#[doc = "Generated from 'VK_KHR_shader_float_controls'"]
-impl ShaderFloatControlsIndependence {
     pub const ALL_KHR: Self = Self::ALL;
+    pub const NONE_KHR: Self = Self::NONE;
 }
 #[doc = "Generated from 'VK_KHR_shader_float_controls'"]
-impl ShaderFloatControlsIndependence {
-    pub const NONE_KHR: Self = Self::NONE;
+impl StructureType {
+    pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: Self =
+        Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
 }
 impl NvShaderSubgroupPartitionedFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shader_subgroup_partitioned\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_subgroup_partitioned\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15679,7 +12043,7 @@ impl NvShaderSubgroupPartitionedFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvShaderSubgroupPartitionedFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_shader_subgroup_partitioned'"]
@@ -15687,9 +12051,11 @@ impl SubgroupFeatureFlags {
     pub const PARTITIONED_NV: Self = Self(0b1_0000_0000);
 }
 impl KhrDepthStencilResolveFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_depth_stencil_resolve\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_depth_stencil_resolve\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15702,43 +12068,30 @@ impl KhrDepthStencilResolveFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDepthStencilResolveFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: Self =
-        Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
-}
-#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
-impl StructureType {
-    pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: Self =
-        Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
-}
-#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
 impl ResolveModeFlags {
     pub const NONE_KHR: Self = Self::NONE;
-}
-#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
-impl ResolveModeFlags {
     pub const SAMPLE_ZERO_KHR: Self = Self::SAMPLE_ZERO;
-}
-#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
-impl ResolveModeFlags {
     pub const AVERAGE_KHR: Self = Self::AVERAGE;
-}
-#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
-impl ResolveModeFlags {
     pub const MIN_KHR: Self = Self::MIN;
+    pub const MAX_KHR: Self = Self::MAX;
 }
 #[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
-impl ResolveModeFlags {
-    pub const MAX_KHR: Self = Self::MAX;
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: Self =
+        Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
+    pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: Self =
+        Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
 }
 impl KhrSwapchainMutableFormatFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_swapchain_mutable_format\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain_mutable_format\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15751,7 +12104,7 @@ impl KhrSwapchainMutableFormatFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSwapchainMutableFormatFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_swapchain_mutable_format'"]
@@ -15759,9 +12112,11 @@ impl SwapchainCreateFlagsKHR {
     pub const MUTABLE_FORMAT: Self = Self(0b100);
 }
 impl NvComputeShaderDerivativesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_compute_shader_derivatives\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_compute_shader_derivatives\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15774,7 +12129,7 @@ impl NvComputeShaderDerivativesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvComputeShaderDerivativesFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_compute_shader_derivatives'"]
@@ -15782,9 +12137,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: Self = Self(1_000_201_000);
 }
 impl NvMeshShaderFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_mesh_shader\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_mesh_shader\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15822,7 +12177,7 @@ impl NvMeshShaderFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvMeshShaderFn {
+        Self {
             cmd_draw_mesh_tasks_nv: unsafe {
                 unsafe extern "system" fn cmd_draw_mesh_tasks_nv(
                     _command_buffer: CommandBuffer,
@@ -15893,76 +12248,28 @@ impl NvMeshShaderFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawMeshTasksNV.html>"]
-    pub unsafe fn cmd_draw_mesh_tasks_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        task_count: u32,
-        first_task: u32,
-    ) {
-        (self.cmd_draw_mesh_tasks_nv)(command_buffer, task_count, first_task)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawMeshTasksIndirectNV.html>"]
-    pub unsafe fn cmd_draw_mesh_tasks_indirect_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_mesh_tasks_indirect_nv)(command_buffer, buffer, offset, draw_count, stride)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawMeshTasksIndirectCountNV.html>"]
-    pub unsafe fn cmd_draw_mesh_tasks_indirect_count_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        count_buffer: Buffer,
-        count_buffer_offset: DeviceSize,
-        max_draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_mesh_tasks_indirect_count_nv)(
-            command_buffer,
-            buffer,
-            offset,
-            count_buffer,
-            count_buffer_offset,
-            max_draw_count,
-            stride,
-        )
-    }
 }
 #[doc = "Generated from 'VK_NV_mesh_shader'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1_000_202_000);
-}
-#[doc = "Generated from 'VK_NV_mesh_shader'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: Self = Self(1_000_202_001);
-}
-#[doc = "Generated from 'VK_NV_mesh_shader'"]
-impl ShaderStageFlags {
-    pub const TASK_NV: Self = Self(0b100_0000);
+impl PipelineStageFlags {
+    pub const TASK_SHADER_NV: Self = Self::TASK_SHADER_EXT;
+    pub const MESH_SHADER_NV: Self = Self::MESH_SHADER_EXT;
 }
 #[doc = "Generated from 'VK_NV_mesh_shader'"]
 impl ShaderStageFlags {
-    pub const MESH_NV: Self = Self(0b1000_0000);
+    pub const TASK_NV: Self = Self::TASK_EXT;
+    pub const MESH_NV: Self = Self::MESH_EXT;
 }
 #[doc = "Generated from 'VK_NV_mesh_shader'"]
-impl PipelineStageFlags {
-    pub const TASK_SHADER_NV: Self = Self(0b1000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_NV_mesh_shader'"]
-impl PipelineStageFlags {
-    pub const MESH_SHADER_NV: Self = Self(0b1_0000_0000_0000_0000_0000);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1_000_202_000);
+    pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: Self = Self(1_000_202_001);
 }
 impl NvFragmentShaderBarycentricFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_fragment_shader_barycentric\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shader_barycentric\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -15975,17 +12282,20 @@ impl NvFragmentShaderBarycentricFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvFragmentShaderBarycentricFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_fragment_shader_barycentric'"]
 impl StructureType {
-    pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self = Self(1_000_203_000);
+    pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self =
+        Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
 }
 impl NvShaderImageFootprintFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_shader_image_footprint\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_image_footprint\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -15998,7 +12308,7 @@ impl NvShaderImageFootprintFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvShaderImageFootprintFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_shader_image_footprint'"]
@@ -16006,13 +12316,20 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: Self = Self(1_000_204_000);
 }
 impl NvScissorExclusiveFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_scissor_exclusive\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_scissor_exclusive\0") }
     }
-    pub const SPEC_VERSION: u32 = 1u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
 #[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetExclusiveScissorEnableNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    first_exclusive_scissor: u32,
+    exclusive_scissor_count: u32,
+    p_exclusive_scissor_enables: *const Bool32,
+);
+#[allow(non_camel_case_types)]
 pub type PFN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     first_exclusive_scissor: u32,
@@ -16021,6 +12338,7 @@ pub type PFN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn(
 );
 #[derive(Clone)]
 pub struct NvScissorExclusiveFn {
+    pub cmd_set_exclusive_scissor_enable_nv: PFN_vkCmdSetExclusiveScissorEnableNV,
     pub cmd_set_exclusive_scissor_nv: PFN_vkCmdSetExclusiveScissorNV,
 }
 unsafe impl Send for NvScissorExclusiveFn {}
@@ -16030,7 +12348,29 @@ impl NvScissorExclusiveFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvScissorExclusiveFn {
+        Self {
+            cmd_set_exclusive_scissor_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_exclusive_scissor_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _first_exclusive_scissor: u32,
+                    _exclusive_scissor_count: u32,
+                    _p_exclusive_scissor_enables: *const Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_exclusive_scissor_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetExclusiveScissorEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_exclusive_scissor_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
             cmd_set_exclusive_scissor_nv: unsafe {
                 unsafe extern "system" fn cmd_set_exclusive_scissor_nv(
                     _command_buffer: CommandBuffer,
@@ -16055,38 +12395,25 @@ impl NvScissorExclusiveFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetExclusiveScissorNV.html>"]
-    pub unsafe fn cmd_set_exclusive_scissor_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        first_exclusive_scissor: u32,
-        exclusive_scissor_count: u32,
-        p_exclusive_scissors: *const Rect2D,
-    ) {
-        (self.cmd_set_exclusive_scissor_nv)(
-            command_buffer,
-            first_exclusive_scissor,
-            exclusive_scissor_count,
-            p_exclusive_scissors,
-        )
-    }
-}
-#[doc = "Generated from 'VK_NV_scissor_exclusive'"]
-impl StructureType {
-    pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self(1_000_205_000);
 }
 #[doc = "Generated from 'VK_NV_scissor_exclusive'"]
 impl DynamicState {
+    pub const EXCLUSIVE_SCISSOR_ENABLE_NV: Self = Self(1_000_205_000);
     pub const EXCLUSIVE_SCISSOR_NV: Self = Self(1_000_205_001);
 }
 #[doc = "Generated from 'VK_NV_scissor_exclusive'"]
 impl StructureType {
+    pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self(1_000_205_000);
     pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: Self = Self(1_000_205_002);
 }
 impl NvDeviceDiagnosticCheckpointsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_diagnostic_checkpoints\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_NV_device_diagnostic_checkpoints\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -16111,7 +12438,7 @@ impl NvDeviceDiagnosticCheckpointsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvDeviceDiagnosticCheckpointsFn {
+        Self {
             cmd_set_checkpoint_nv: unsafe {
                 unsafe extern "system" fn cmd_set_checkpoint_nv(
                     _command_buffer: CommandBuffer,
@@ -16154,36 +12481,16 @@ impl NvDeviceDiagnosticCheckpointsFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetCheckpointNV.html>"]
-    pub unsafe fn cmd_set_checkpoint_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        p_checkpoint_marker: *const c_void,
-    ) {
-        (self.cmd_set_checkpoint_nv)(command_buffer, p_checkpoint_marker)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetQueueCheckpointDataNV.html>"]
-    pub unsafe fn get_queue_checkpoint_data_nv(
-        &self,
-        queue: Queue,
-        p_checkpoint_data_count: *mut u32,
-        p_checkpoint_data: *mut CheckpointDataNV,
-    ) {
-        (self.get_queue_checkpoint_data_nv)(queue, p_checkpoint_data_count, p_checkpoint_data)
-    }
 }
 #[doc = "Generated from 'VK_NV_device_diagnostic_checkpoints'"]
 impl StructureType {
     pub const CHECKPOINT_DATA_NV: Self = Self(1_000_206_000);
-}
-#[doc = "Generated from 'VK_NV_device_diagnostic_checkpoints'"]
-impl StructureType {
     pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: Self = Self(1_000_206_001);
 }
 impl KhrTimelineSemaphoreFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_timeline_semaphore\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_timeline_semaphore\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -16212,7 +12519,7 @@ impl KhrTimelineSemaphoreFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrTimelineSemaphoreFn {
+        Self {
             get_semaphore_counter_value_khr: unsafe {
                 unsafe extern "system" fn get_semaphore_counter_value_khr(
                     _device: Device,
@@ -16269,75 +12576,31 @@ impl KhrTimelineSemaphoreFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreCounterValueKHR.html>"]
-    pub unsafe fn get_semaphore_counter_value_khr(
-        &self,
-        device: Device,
-        semaphore: Semaphore,
-        p_value: *mut u64,
-    ) -> Result {
-        (self.get_semaphore_counter_value_khr)(device, semaphore, p_value)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitSemaphoresKHR.html>"]
-    pub unsafe fn wait_semaphores_khr(
-        &self,
-        device: Device,
-        p_wait_info: *const SemaphoreWaitInfo,
-        timeout: u64,
-    ) -> Result {
-        (self.wait_semaphores_khr)(device, p_wait_info, timeout)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSignalSemaphoreKHR.html>"]
-    pub unsafe fn signal_semaphore_khr(
-        &self,
-        device: Device,
-        p_signal_info: *const SemaphoreSignalInfo,
-    ) -> Result {
-        (self.signal_semaphore_khr)(device, p_signal_info)
-    }
 }
 #[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: Self =
-        Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+impl SemaphoreType {
+    pub const BINARY_KHR: Self = Self::BINARY;
+    pub const TIMELINE_KHR: Self = Self::TIMELINE;
 }
 #[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: Self =
-        Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
+impl SemaphoreWaitFlags {
+    pub const ANY_KHR: Self = Self::ANY;
 }
 #[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
+    pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: Self =
+        Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
     pub const SEMAPHORE_TYPE_CREATE_INFO_KHR: Self = Self::SEMAPHORE_TYPE_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
-impl StructureType {
     pub const TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::TIMELINE_SEMAPHORE_SUBMIT_INFO;
-}
-#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
-impl StructureType {
     pub const SEMAPHORE_WAIT_INFO_KHR: Self = Self::SEMAPHORE_WAIT_INFO;
-}
-#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
-impl StructureType {
     pub const SEMAPHORE_SIGNAL_INFO_KHR: Self = Self::SEMAPHORE_SIGNAL_INFO;
 }
-#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
-impl SemaphoreType {
-    pub const BINARY_KHR: Self = Self::BINARY;
-}
-#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
-impl SemaphoreType {
-    pub const TIMELINE_KHR: Self = Self::TIMELINE;
-}
-#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
-impl SemaphoreWaitFlags {
-    pub const ANY_KHR: Self = Self::ANY;
-}
 impl KhrExtension209Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_209\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_209\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -16350,13 +12613,15 @@ impl KhrExtension209Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension209Fn {}
+        Self {}
     }
 }
 impl IntelShaderIntegerFunctions2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_shader_integer_functions2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_shader_integer_functions2\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -16369,7 +12634,7 @@ impl IntelShaderIntegerFunctions2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        IntelShaderIntegerFunctions2Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_INTEL_shader_integer_functions2'"]
@@ -16377,9 +12642,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: Self = Self(1_000_209_000);
 }
 impl IntelPerformanceQueryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_performance_query\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_performance_query\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -16444,7 +12709,7 @@ impl IntelPerformanceQueryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        IntelPerformanceQueryFn {
+        Self {
             initialize_performance_api_intel: unsafe {
                 unsafe extern "system" fn initialize_performance_api_intel(
                     _device: Device,
@@ -16626,118 +12891,28 @@ impl IntelPerformanceQueryFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkInitializePerformanceApiINTEL.html>"]
-    pub unsafe fn initialize_performance_api_intel(
-        &self,
-        device: Device,
-        p_initialize_info: *const InitializePerformanceApiInfoINTEL,
-    ) -> Result {
-        (self.initialize_performance_api_intel)(device, p_initialize_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUninitializePerformanceApiINTEL.html>"]
-    pub unsafe fn uninitialize_performance_api_intel(&self, device: Device) {
-        (self.uninitialize_performance_api_intel)(device)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetPerformanceMarkerINTEL.html>"]
-    pub unsafe fn cmd_set_performance_marker_intel(
-        &self,
-        command_buffer: CommandBuffer,
-        p_marker_info: *const PerformanceMarkerInfoINTEL,
-    ) -> Result {
-        (self.cmd_set_performance_marker_intel)(command_buffer, p_marker_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html>"]
-    pub unsafe fn cmd_set_performance_stream_marker_intel(
-        &self,
-        command_buffer: CommandBuffer,
-        p_marker_info: *const PerformanceStreamMarkerInfoINTEL,
-    ) -> Result {
-        (self.cmd_set_performance_stream_marker_intel)(command_buffer, p_marker_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetPerformanceOverrideINTEL.html>"]
-    pub unsafe fn cmd_set_performance_override_intel(
-        &self,
-        command_buffer: CommandBuffer,
-        p_override_info: *const PerformanceOverrideInfoINTEL,
-    ) -> Result {
-        (self.cmd_set_performance_override_intel)(command_buffer, p_override_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquirePerformanceConfigurationINTEL.html>"]
-    pub unsafe fn acquire_performance_configuration_intel(
-        &self,
-        device: Device,
-        p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL,
-        p_configuration: *mut PerformanceConfigurationINTEL,
-    ) -> Result {
-        (self.acquire_performance_configuration_intel)(device, p_acquire_info, p_configuration)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkReleasePerformanceConfigurationINTEL.html>"]
-    pub unsafe fn release_performance_configuration_intel(
-        &self,
-        device: Device,
-        configuration: PerformanceConfigurationINTEL,
-    ) -> Result {
-        (self.release_performance_configuration_intel)(device, configuration)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueSetPerformanceConfigurationINTEL.html>"]
-    pub unsafe fn queue_set_performance_configuration_intel(
-        &self,
-        queue: Queue,
-        configuration: PerformanceConfigurationINTEL,
-    ) -> Result {
-        (self.queue_set_performance_configuration_intel)(queue, configuration)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPerformanceParameterINTEL.html>"]
-    pub unsafe fn get_performance_parameter_intel(
-        &self,
-        device: Device,
-        parameter: PerformanceParameterTypeINTEL,
-        p_value: *mut PerformanceValueINTEL,
-    ) -> Result {
-        (self.get_performance_parameter_intel)(device, parameter, p_value)
-    }
 }
 #[doc = "Generated from 'VK_INTEL_performance_query'"]
-impl StructureType {
-    pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: Self = Self(1_000_210_000);
+impl ObjectType {
+    pub const PERFORMANCE_CONFIGURATION_INTEL: Self = Self(1_000_210_000);
 }
 #[doc = "Generated from 'VK_INTEL_performance_query'"]
-impl StructureType {
-    pub const QUERY_POOL_CREATE_INFO_INTEL: Self =
-        Self::QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
+impl QueryType {
+    pub const PERFORMANCE_QUERY_INTEL: Self = Self(1_000_210_000);
 }
 #[doc = "Generated from 'VK_INTEL_performance_query'"]
 impl StructureType {
+    pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: Self = Self(1_000_210_000);
     pub const INITIALIZE_PERFORMANCE_API_INFO_INTEL: Self = Self(1_000_210_001);
-}
-#[doc = "Generated from 'VK_INTEL_performance_query'"]
-impl StructureType {
     pub const PERFORMANCE_MARKER_INFO_INTEL: Self = Self(1_000_210_002);
-}
-#[doc = "Generated from 'VK_INTEL_performance_query'"]
-impl StructureType {
     pub const PERFORMANCE_STREAM_MARKER_INFO_INTEL: Self = Self(1_000_210_003);
-}
-#[doc = "Generated from 'VK_INTEL_performance_query'"]
-impl StructureType {
     pub const PERFORMANCE_OVERRIDE_INFO_INTEL: Self = Self(1_000_210_004);
-}
-#[doc = "Generated from 'VK_INTEL_performance_query'"]
-impl StructureType {
     pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: Self = Self(1_000_210_005);
 }
-#[doc = "Generated from 'VK_INTEL_performance_query'"]
-impl QueryType {
-    pub const PERFORMANCE_QUERY_INTEL: Self = Self(1_000_210_000);
-}
-#[doc = "Generated from 'VK_INTEL_performance_query'"]
-impl ObjectType {
-    pub const PERFORMANCE_CONFIGURATION_INTEL: Self = Self(1_000_210_000);
-}
 impl KhrVulkanMemoryModelFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_vulkan_memory_model\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_vulkan_memory_model\0") }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -16750,7 +12925,7 @@ impl KhrVulkanMemoryModelFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrVulkanMemoryModelFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_vulkan_memory_model'"]
@@ -16759,9 +12934,9 @@ impl StructureType {
         Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
 }
 impl ExtPciBusInfoFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pci_bus_info\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pci_bus_info\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -16774,7 +12949,7 @@ impl ExtPciBusInfoFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtPciBusInfoFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_pci_bus_info'"]
@@ -16782,9 +12957,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: Self = Self(1_000_212_000);
 }
 impl AmdDisplayNativeHdrFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_display_native_hdr\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_display_native_hdr\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -16805,7 +12980,7 @@ impl AmdDisplayNativeHdrFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdDisplayNativeHdrFn {
+        Self {
             set_local_dimming_amd: unsafe {
                 unsafe extern "system" fn set_local_dimming_amd(
                     _device: Device,
@@ -16828,32 +13003,22 @@ impl AmdDisplayNativeHdrFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetLocalDimmingAMD.html>"]
-    pub unsafe fn set_local_dimming_amd(
-        &self,
-        device: Device,
-        swap_chain: SwapchainKHR,
-        local_dimming_enable: Bool32,
-    ) {
-        (self.set_local_dimming_amd)(device, swap_chain, local_dimming_enable)
-    }
 }
 #[doc = "Generated from 'VK_AMD_display_native_hdr'"]
-impl StructureType {
-    pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1_000_213_000);
+impl ColorSpaceKHR {
+    pub const DISPLAY_NATIVE_AMD: Self = Self(1_000_213_000);
 }
 #[doc = "Generated from 'VK_AMD_display_native_hdr'"]
 impl StructureType {
+    pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1_000_213_000);
     pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: Self = Self(1_000_213_001);
 }
-#[doc = "Generated from 'VK_AMD_display_native_hdr'"]
-impl ColorSpaceKHR {
-    pub const DISPLAY_NATIVE_AMD: Self = Self(1_000_213_000);
-}
 impl FuchsiaImagepipeSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_imagepipe_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_imagepipe_surface\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -16875,7 +13040,7 @@ impl FuchsiaImagepipeSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        FuchsiaImagepipeSurfaceFn {
+        Self {
             create_image_pipe_surface_fuchsia: unsafe {
                 unsafe extern "system" fn create_image_pipe_surface_fuchsia(
                     _instance: Instance,
@@ -16900,25 +13065,17 @@ impl FuchsiaImagepipeSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImagePipeSurfaceFUCHSIA.html>"]
-    pub unsafe fn create_image_pipe_surface_fuchsia(
-        &self,
-        instance: Instance,
-        p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_image_pipe_surface_fuchsia)(instance, p_create_info, p_allocator, p_surface)
-    }
 }
 #[doc = "Generated from 'VK_FUCHSIA_imagepipe_surface'"]
 impl StructureType {
     pub const IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: Self = Self(1_000_214_000);
 }
 impl KhrShaderTerminateInvocationFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_terminate_invocation\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_terminate_invocation\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -16931,17 +13088,18 @@ impl KhrShaderTerminateInvocationFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderTerminateInvocationFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_shader_terminate_invocation'"]
 impl StructureType {
-    pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: Self = Self(1_000_215_000);
+    pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
 }
 impl GoogleExtension217Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_217\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_217\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -16954,13 +13112,13 @@ impl GoogleExtension217Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GoogleExtension217Fn {}
+        Self {}
     }
 }
 impl ExtMetalSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_metal_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -16982,7 +13140,7 @@ impl ExtMetalSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtMetalSurfaceFn {
+        Self {
             create_metal_surface_ext: unsafe {
                 unsafe extern "system" fn create_metal_surface_ext(
                     _instance: Instance,
@@ -17006,27 +13164,17 @@ impl ExtMetalSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateMetalSurfaceEXT.html>"]
-    pub unsafe fn create_metal_surface_ext(
-        &self,
-        instance: Instance,
-        p_create_info: *const MetalSurfaceCreateInfoEXT,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_metal_surface_ext)(instance, p_create_info, p_allocator, p_surface)
-    }
 }
 #[doc = "Generated from 'VK_EXT_metal_surface'"]
 impl StructureType {
     pub const METAL_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_217_000);
 }
 impl ExtFragmentDensityMapFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_fragment_density_map\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map\0") }
     }
-    pub const SPEC_VERSION: u32 = 1u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
 #[derive(Clone)]
 pub struct ExtFragmentDensityMapFn {}
@@ -17037,20 +13185,20 @@ impl ExtFragmentDensityMapFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtFragmentDensityMapFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_fragment_density_map'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: Self = Self(1_000_218_000);
+impl AccessFlags {
+    pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_fragment_density_map'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1_000_218_001);
+impl FormatFeatureFlags {
+    pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_fragment_density_map'"]
-impl StructureType {
-    pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: Self = Self(1_000_218_002);
+impl FormatFeatureFlags2 {
+    pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_EXT_fragment_density_map'"]
 impl ImageCreateFlags {
@@ -17061,14 +13209,6 @@ impl ImageLayout {
     pub const FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: Self = Self(1_000_218_000);
 }
 #[doc = "Generated from 'VK_EXT_fragment_density_map'"]
-impl AccessFlags {
-    pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
-impl FormatFeatureFlags {
-    pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
 impl ImageUsageFlags {
     pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b10_0000_0000);
 }
@@ -17083,15 +13223,18 @@ impl PipelineStageFlags {
 #[doc = "Generated from 'VK_EXT_fragment_density_map'"]
 impl SamplerCreateFlags {
     pub const SUBSAMPLED_EXT: Self = Self(0b1);
+    pub const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT: Self = Self(0b10);
 }
 #[doc = "Generated from 'VK_EXT_fragment_density_map'"]
-impl SamplerCreateFlags {
-    pub const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT: Self = Self(0b10);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: Self = Self(1_000_218_000);
+    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1_000_218_001);
+    pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: Self = Self(1_000_218_002);
 }
 impl ExtExtension220Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_220\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_220\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17104,13 +13247,13 @@ impl ExtExtension220Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension220Fn {}
+        Self {}
     }
 }
 impl KhrExtension221Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_221\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_221\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17123,7 +13266,7 @@ impl KhrExtension221Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension221Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_extension_221'"]
@@ -17131,9 +13274,9 @@ impl RenderPassCreateFlags {
     pub const RESERVED_0_KHR: Self = Self(0b1);
 }
 impl ExtScalarBlockLayoutFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_scalar_block_layout\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_scalar_block_layout\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17146,7 +13289,7 @@ impl ExtScalarBlockLayoutFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtScalarBlockLayoutFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_scalar_block_layout'"]
@@ -17155,9 +13298,9 @@ impl StructureType {
         Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
 }
 impl ExtExtension223Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_223\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_223\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17170,13 +13313,15 @@ impl ExtExtension223Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension223Fn {}
+        Self {}
     }
 }
 impl GoogleHlslFunctionality1Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_hlsl_functionality1\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_hlsl_functionality1\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17189,13 +13334,13 @@ impl GoogleHlslFunctionality1Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GoogleHlslFunctionality1Fn {}
+        Self {}
     }
 }
 impl GoogleDecorateStringFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_decorate_string\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_decorate_string\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17208,13 +13353,15 @@ impl GoogleDecorateStringFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GoogleDecorateStringFn {}
+        Self {}
     }
 }
 impl ExtSubgroupSizeControlFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_subgroup_size_control\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subgroup_size_control\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -17227,36 +13374,31 @@ impl ExtSubgroupSizeControlFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtSubgroupSizeControlFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_subgroup_size_control'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: Self = Self(1_000_225_000);
+impl PipelineShaderStageCreateFlags {
+    pub const ALLOW_VARYING_SUBGROUP_SIZE_EXT: Self = Self::ALLOW_VARYING_SUBGROUP_SIZE;
+    pub const REQUIRE_FULL_SUBGROUPS_EXT: Self = Self::REQUIRE_FULL_SUBGROUPS;
 }
 #[doc = "Generated from 'VK_EXT_subgroup_size_control'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: Self =
+        Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
     pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self =
-        Self(1_000_225_001);
-}
-#[doc = "Generated from 'VK_EXT_subgroup_size_control'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: Self = Self(1_000_225_002);
-}
-#[doc = "Generated from 'VK_EXT_subgroup_size_control'"]
-impl PipelineShaderStageCreateFlags {
-    pub const ALLOW_VARYING_SUBGROUP_SIZE_EXT: Self = Self(0b1);
-}
-#[doc = "Generated from 'VK_EXT_subgroup_size_control'"]
-impl PipelineShaderStageCreateFlags {
-    pub const REQUIRE_FULL_SUBGROUPS_EXT: Self = Self(0b10);
+        Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
+    pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: Self =
+        Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
 }
 impl KhrFragmentShadingRateFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_fragment_shading_rate\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shading_rate\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 1u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn(
@@ -17268,7 +13410,7 @@ pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system"
 pub type PFN_vkCmdSetFragmentShadingRateKHR = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     p_fragment_size: *const Extent2D,
-    combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
+    combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
 );
 #[derive(Clone)]
 pub struct KhrFragmentShadingRateFn {
@@ -17283,7 +13425,7 @@ impl KhrFragmentShadingRateFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrFragmentShadingRateFn {
+        Self {
             get_physical_device_fragment_shading_rates_khr: unsafe {
                 unsafe extern "system" fn get_physical_device_fragment_shading_rates_khr(
                     _physical_device: PhysicalDevice,
@@ -17309,7 +13451,7 @@ impl KhrFragmentShadingRateFn {
                 unsafe extern "system" fn cmd_set_fragment_shading_rate_khr(
                     _command_buffer: CommandBuffer,
                     _p_fragment_size: *const Extent2D,
-                    _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
+                    _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
                 ) {
                     panic!(concat!(
                         "Unable to load ",
@@ -17328,61 +13470,29 @@ impl KhrFragmentShadingRateFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html>"]
-    pub unsafe fn get_physical_device_fragment_shading_rates_khr(
-        &self,
-        physical_device: PhysicalDevice,
-        p_fragment_shading_rate_count: *mut u32,
-        p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR,
-    ) -> Result {
-        (self.get_physical_device_fragment_shading_rates_khr)(
-            physical_device,
-            p_fragment_shading_rate_count,
-            p_fragment_shading_rates,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetFragmentShadingRateKHR.html>"]
-    pub unsafe fn cmd_set_fragment_shading_rate_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_fragment_size: *const Extent2D,
-        combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
-    ) {
-        (self.cmd_set_fragment_shading_rate_khr)(command_buffer, p_fragment_size, combiner_ops)
-    }
 }
 #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
-impl ImageLayout {
-    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self(1_000_164_003);
+impl AccessFlags {
+    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self =
+        Self(0b1000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
 impl DynamicState {
     pub const FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_000);
 }
 #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
-impl StructureType {
-    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_226_000);
-}
-#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
-impl StructureType {
-    pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: Self = Self(1_000_226_001);
-}
-#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: Self = Self(1_000_226_002);
-}
-#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: Self = Self(1_000_226_003);
+impl FormatFeatureFlags {
+    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_004);
+impl FormatFeatureFlags2 {
+    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
-impl AccessFlags {
-    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self =
-        Self(0b1000_0000_0000_0000_0000_0000);
+impl ImageLayout {
+    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self(1_000_164_003);
 }
 #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
 impl ImageUsageFlags {
@@ -17393,14 +13503,19 @@ impl PipelineStageFlags {
     pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
-impl FormatFeatureFlags {
-    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
-        Self(0b100_0000_0000_0000_0000_0000_0000_0000);
+impl StructureType {
+    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_226_000);
+    pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: Self = Self(1_000_226_001);
+    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: Self = Self(1_000_226_002);
+    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: Self = Self(1_000_226_003);
+    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_004);
 }
 impl AmdShaderCoreProperties2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_shader_core_properties2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties2\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17413,7 +13528,7 @@ impl AmdShaderCoreProperties2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdShaderCoreProperties2Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_AMD_shader_core_properties2'"]
@@ -17421,9 +13536,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: Self = Self(1_000_227_000);
 }
 impl AmdExtension229Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_229\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_229\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17436,13 +13551,15 @@ impl AmdExtension229Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension229Fn {}
+        Self {}
     }
 }
 impl AmdDeviceCoherentMemoryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_device_coherent_memory\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_device_coherent_memory\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17455,15 +13572,12 @@ impl AmdDeviceCoherentMemoryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdDeviceCoherentMemoryFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_AMD_device_coherent_memory'"]
 impl MemoryPropertyFlags {
     pub const DEVICE_COHERENT_AMD: Self = Self(0b100_0000);
-}
-#[doc = "Generated from 'VK_AMD_device_coherent_memory'"]
-impl MemoryPropertyFlags {
     pub const DEVICE_UNCACHED_AMD: Self = Self(0b1000_0000);
 }
 #[doc = "Generated from 'VK_AMD_device_coherent_memory'"]
@@ -17471,9 +13585,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: Self = Self(1_000_229_000);
 }
 impl AmdExtension231Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_231\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_231\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17486,13 +13600,13 @@ impl AmdExtension231Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension231Fn {}
+        Self {}
     }
 }
 impl AmdExtension232Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_232\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_232\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17505,13 +13619,13 @@ impl AmdExtension232Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension232Fn {}
+        Self {}
     }
 }
 impl AmdExtension233Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_233\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_233\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17524,13 +13638,13 @@ impl AmdExtension233Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension233Fn {}
+        Self {}
     }
 }
 impl AmdExtension234Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_234\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_234\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17543,13 +13657,15 @@ impl AmdExtension234Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension234Fn {}
+        Self {}
     }
 }
 impl ExtShaderImageAtomicInt64Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_image_atomic_int64\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_image_atomic_int64\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17562,7 +13678,7 @@ impl ExtShaderImageAtomicInt64Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtShaderImageAtomicInt64Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_shader_image_atomic_int64'"]
@@ -17570,9 +13686,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: Self = Self(1_000_234_000);
 }
 impl AmdExtension236Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_236\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_236\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17585,13 +13701,13 @@ impl AmdExtension236Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension236Fn {}
+        Self {}
     }
 }
 impl KhrSpirv14Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_spirv_1_4\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_spirv_1_4\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17604,13 +13720,13 @@ impl KhrSpirv14Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSpirv14Fn {}
+        Self {}
     }
 }
 impl ExtMemoryBudgetFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_memory_budget\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_budget\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17623,7 +13739,7 @@ impl ExtMemoryBudgetFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtMemoryBudgetFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_memory_budget'"]
@@ -17631,9 +13747,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: Self = Self(1_000_237_000);
 }
 impl ExtMemoryPriorityFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_memory_priority\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_priority\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17646,21 +13762,22 @@ impl ExtMemoryPriorityFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtMemoryPriorityFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_memory_priority'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: Self = Self(1_000_238_000);
-}
-#[doc = "Generated from 'VK_EXT_memory_priority'"]
-impl StructureType {
     pub const MEMORY_PRIORITY_ALLOCATE_INFO_EXT: Self = Self(1_000_238_001);
 }
 impl KhrSurfaceProtectedCapabilitiesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_surface_protected_capabilities\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_surface_protected_capabilities\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17673,7 +13790,7 @@ impl KhrSurfaceProtectedCapabilitiesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSurfaceProtectedCapabilitiesFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_surface_protected_capabilities'"]
@@ -17681,9 +13798,13 @@ impl StructureType {
     pub const SURFACE_PROTECTED_CAPABILITIES_KHR: Self = Self(1_000_239_000);
 }
 impl NvDedicatedAllocationImageAliasingFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_dedicated_allocation_image_aliasing\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_NV_dedicated_allocation_image_aliasing\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17696,7 +13817,7 @@ impl NvDedicatedAllocationImageAliasingFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvDedicatedAllocationImageAliasingFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_dedicated_allocation_image_aliasing'"]
@@ -17705,9 +13826,13 @@ impl StructureType {
         Self(1_000_240_000);
 }
 impl KhrSeparateDepthStencilLayoutsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_separate_depth_stencil_layouts\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_separate_depth_stencil_layouts\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17720,44 +13845,29 @@ impl KhrSeparateDepthStencilLayoutsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSeparateDepthStencilLayoutsFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: Self =
-        Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
+impl ImageLayout {
+    pub const DEPTH_ATTACHMENT_OPTIMAL_KHR: Self = Self::DEPTH_ATTACHMENT_OPTIMAL;
+    pub const DEPTH_READ_ONLY_OPTIMAL_KHR: Self = Self::DEPTH_READ_ONLY_OPTIMAL;
+    pub const STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = Self::STENCIL_ATTACHMENT_OPTIMAL;
+    pub const STENCIL_READ_ONLY_OPTIMAL_KHR: Self = Self::STENCIL_READ_ONLY_OPTIMAL;
 }
 #[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
     pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: Self =
         Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
-}
-#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
-impl StructureType {
     pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: Self =
         Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
 }
-#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
-impl ImageLayout {
-    pub const DEPTH_ATTACHMENT_OPTIMAL_KHR: Self = Self::DEPTH_ATTACHMENT_OPTIMAL;
-}
-#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
-impl ImageLayout {
-    pub const DEPTH_READ_ONLY_OPTIMAL_KHR: Self = Self::DEPTH_READ_ONLY_OPTIMAL;
-}
-#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
-impl ImageLayout {
-    pub const STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = Self::STENCIL_ATTACHMENT_OPTIMAL;
-}
-#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
-impl ImageLayout {
-    pub const STENCIL_READ_ONLY_OPTIMAL_KHR: Self = Self::STENCIL_READ_ONLY_OPTIMAL;
-}
 impl IntelExtension243Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_243\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_243\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17770,13 +13880,18 @@ impl IntelExtension243Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        IntelExtension243Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_INTEL_extension_243'"]
+impl AccessFlags2 {
+    pub const RESERVED_46_EXT: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
 impl MesaExtension244Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_MESA_extension_244\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_244\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -17789,13 +13904,15 @@ impl MesaExtension244Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        MesaExtension244Fn {}
+        Self {}
     }
 }
 impl ExtBufferDeviceAddressFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_buffer_device_address\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_buffer_device_address\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -17815,7 +13932,7 @@ impl ExtBufferDeviceAddressFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtBufferDeviceAddressFn {
+        Self {
             get_buffer_device_address_ext: unsafe {
                 unsafe extern "system" fn get_buffer_device_address_ext(
                     _device: Device,
@@ -17838,60 +13955,43 @@ impl ExtBufferDeviceAddressFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferDeviceAddressEXT.html>"]
-    pub unsafe fn get_buffer_device_address_ext(
-        &self,
-        device: Device,
-        p_info: *const BufferDeviceAddressInfo,
-    ) -> DeviceAddress {
-        (self.get_buffer_device_address_ext)(device, p_info)
-    }
-}
-#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: Self = Self(1_000_244_000);
-}
-#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: Self =
-        Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
 }
 #[doc = "Generated from 'VK_EXT_buffer_device_address'"]
-impl StructureType {
-    pub const BUFFER_DEVICE_ADDRESS_INFO_EXT: Self = Self::BUFFER_DEVICE_ADDRESS_INFO;
-}
-#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
-impl StructureType {
-    pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: Self = Self(1_000_244_002);
+impl BufferCreateFlags {
+    pub const DEVICE_ADDRESS_CAPTURE_REPLAY_EXT: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
 }
 #[doc = "Generated from 'VK_EXT_buffer_device_address'"]
 impl BufferUsageFlags {
     pub const SHADER_DEVICE_ADDRESS_EXT: Self = Self::SHADER_DEVICE_ADDRESS;
 }
 #[doc = "Generated from 'VK_EXT_buffer_device_address'"]
-impl BufferCreateFlags {
-    pub const DEVICE_ADDRESS_CAPTURE_REPLAY_EXT: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
-}
-#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
 impl Result {
     pub const ERROR_INVALID_DEVICE_ADDRESS_EXT: Self = Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
 }
+#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: Self = Self(1_000_244_000);
+    pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: Self =
+        Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
+    pub const BUFFER_DEVICE_ADDRESS_INFO_EXT: Self = Self::BUFFER_DEVICE_ADDRESS_INFO;
+    pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: Self = Self(1_000_244_002);
+}
 impl ExtToolingInfoFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_tooling_info\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_tooling_info\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
 #[allow(non_camel_case_types)]
-pub type PFN_vkGetPhysicalDeviceToolPropertiesEXT = unsafe extern "system" fn(
+pub type PFN_vkGetPhysicalDeviceToolProperties = unsafe extern "system" fn(
     physical_device: PhysicalDevice,
     p_tool_count: *mut u32,
-    p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT,
+    p_tool_properties: *mut PhysicalDeviceToolProperties,
 ) -> Result;
 #[derive(Clone)]
 pub struct ExtToolingInfoFn {
-    pub get_physical_device_tool_properties_ext: PFN_vkGetPhysicalDeviceToolPropertiesEXT,
+    pub get_physical_device_tool_properties_ext: PFN_vkGetPhysicalDeviceToolProperties,
 }
 unsafe impl Send for ExtToolingInfoFn {}
 unsafe impl Sync for ExtToolingInfoFn {}
@@ -17900,12 +14000,12 @@ impl ExtToolingInfoFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtToolingInfoFn {
+        Self {
             get_physical_device_tool_properties_ext: unsafe {
                 unsafe extern "system" fn get_physical_device_tool_properties_ext(
                     _physical_device: PhysicalDevice,
                     _p_tool_count: *mut u32,
-                    _p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT,
+                    _p_tool_properties: *mut PhysicalDeviceToolProperties,
                 ) -> Result {
                     panic!(concat!(
                         "Unable to load ",
@@ -17924,36 +14024,22 @@ impl ExtToolingInfoFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html>"]
-    pub unsafe fn get_physical_device_tool_properties_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        p_tool_count: *mut u32,
-        p_tool_properties: *mut PhysicalDeviceToolPropertiesEXT,
-    ) -> Result {
-        (self.get_physical_device_tool_properties_ext)(
-            physical_device,
-            p_tool_count,
-            p_tool_properties,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_tooling_info'"]
 impl StructureType {
-    pub const PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: Self = Self(1_000_245_000);
+    pub const PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: Self = Self::PHYSICAL_DEVICE_TOOL_PROPERTIES;
 }
 #[doc = "Generated from 'VK_EXT_tooling_info'"]
-impl ToolPurposeFlagsEXT {
-    pub const DEBUG_REPORTING: Self = Self(0b10_0000);
-}
-#[doc = "Generated from 'VK_EXT_tooling_info'"]
-impl ToolPurposeFlagsEXT {
-    pub const DEBUG_MARKERS: Self = Self(0b100_0000);
+impl ToolPurposeFlags {
+    pub const DEBUG_REPORTING_EXT: Self = Self(0b10_0000);
+    pub const DEBUG_MARKERS_EXT: Self = Self(0b100_0000);
 }
 impl ExtSeparateStencilUsageFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_separate_stencil_usage\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_separate_stencil_usage\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -17966,7 +14052,7 @@ impl ExtSeparateStencilUsageFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtSeparateStencilUsageFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_separate_stencil_usage'"]
@@ -17974,9 +14060,9 @@ impl StructureType {
     pub const IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: Self = Self::IMAGE_STENCIL_USAGE_CREATE_INFO;
 }
 impl ExtValidationFeaturesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_validation_features\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_features\0") }
     }
     pub const SPEC_VERSION: u32 = 5u32;
 }
@@ -17989,7 +14075,7 @@ impl ExtValidationFeaturesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtValidationFeaturesFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_validation_features'"]
@@ -17997,9 +14083,9 @@ impl StructureType {
     pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000);
 }
 impl KhrPresentWaitFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_present_wait\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_wait\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18021,7 +14107,7 @@ impl KhrPresentWaitFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrPresentWaitFn {
+        Self {
             wait_for_present_khr: unsafe {
                 unsafe extern "system" fn wait_for_present_khr(
                     _device: Device,
@@ -18042,25 +14128,15 @@ impl KhrPresentWaitFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitForPresentKHR.html>"]
-    pub unsafe fn wait_for_present_khr(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-        present_id: u64,
-        timeout: u64,
-    ) -> Result {
-        (self.wait_for_present_khr)(device, swapchain, present_id, timeout)
-    }
 }
 #[doc = "Generated from 'VK_KHR_present_wait'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1_000_248_000);
 }
 impl NvCooperativeMatrixFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_cooperative_matrix\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_cooperative_matrix\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18083,7 +14159,7 @@ impl NvCooperativeMatrixFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvCooperativeMatrixFn {
+        Self {
             get_physical_device_cooperative_matrix_properties_nv: unsafe {
                 unsafe extern "system" fn get_physical_device_cooperative_matrix_properties_nv(
                     _physical_device: PhysicalDevice,
@@ -18107,36 +14183,19 @@ impl NvCooperativeMatrixFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html>"]
-    pub unsafe fn get_physical_device_cooperative_matrix_properties_nv(
-        &self,
-        physical_device: PhysicalDevice,
-        p_property_count: *mut u32,
-        p_properties: *mut CooperativeMatrixPropertiesNV,
-    ) -> Result {
-        (self.get_physical_device_cooperative_matrix_properties_nv)(
-            physical_device,
-            p_property_count,
-            p_properties,
-        )
-    }
 }
 #[doc = "Generated from 'VK_NV_cooperative_matrix'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self(1_000_249_000);
-}
-#[doc = "Generated from 'VK_NV_cooperative_matrix'"]
-impl StructureType {
     pub const COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_001);
-}
-#[doc = "Generated from 'VK_NV_cooperative_matrix'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_002);
 }
 impl NvCoverageReductionModeFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_coverage_reduction_mode\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_coverage_reduction_mode\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18159,7 +14218,7 @@ impl NvCoverageReductionModeFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvCoverageReductionModeFn {
+        Self {
             get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: unsafe {
                 unsafe extern "system" fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
                     _physical_device: PhysicalDevice,
@@ -18185,36 +14244,19 @@ impl NvCoverageReductionModeFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html>"]
-    pub unsafe fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
-        &self,
-        physical_device: PhysicalDevice,
-        p_combination_count: *mut u32,
-        p_combinations: *mut FramebufferMixedSamplesCombinationNV,
-    ) -> Result {
-        (self.get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)(
-            physical_device,
-            p_combination_count,
-            p_combinations,
-        )
-    }
 }
 #[doc = "Generated from 'VK_NV_coverage_reduction_mode'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: Self = Self(1_000_250_000);
-}
-#[doc = "Generated from 'VK_NV_coverage_reduction_mode'"]
-impl StructureType {
     pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: Self = Self(1_000_250_001);
-}
-#[doc = "Generated from 'VK_NV_coverage_reduction_mode'"]
-impl StructureType {
     pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: Self = Self(1_000_250_002);
 }
 impl ExtFragmentShaderInterlockFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_fragment_shader_interlock\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_shader_interlock\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18227,7 +14269,7 @@ impl ExtFragmentShaderInterlockFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtFragmentShaderInterlockFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_fragment_shader_interlock'"]
@@ -18235,9 +14277,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: Self = Self(1_000_251_000);
 }
 impl ExtYcbcrImageArraysFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_ycbcr_image_arrays\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_image_arrays\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18250,7 +14292,7 @@ impl ExtYcbcrImageArraysFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtYcbcrImageArraysFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_ycbcr_image_arrays'"]
@@ -18258,9 +14300,13 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: Self = Self(1_000_252_000);
 }
 impl KhrUniformBufferStandardLayoutFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_uniform_buffer_standard_layout\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_uniform_buffer_standard_layout\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18273,7 +14319,7 @@ impl KhrUniformBufferStandardLayoutFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrUniformBufferStandardLayoutFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_uniform_buffer_standard_layout'"]
@@ -18282,9 +14328,9 @@ impl StructureType {
         Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
 }
 impl ExtProvokingVertexFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_provoking_vertex\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_provoking_vertex\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18297,26 +14343,22 @@ impl ExtProvokingVertexFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtProvokingVertexFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_provoking_vertex'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: Self = Self(1_000_254_000);
-}
-#[doc = "Generated from 'VK_EXT_provoking_vertex'"]
-impl StructureType {
     pub const PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: Self =
         Self(1_000_254_001);
-}
-#[doc = "Generated from 'VK_EXT_provoking_vertex'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: Self = Self(1_000_254_002);
 }
 impl ExtFullScreenExclusiveFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_full_screen_exclusive\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_full_screen_exclusive\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 4u32;
 }
@@ -18354,7 +14396,7 @@ impl ExtFullScreenExclusiveFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtFullScreenExclusiveFn {
+        Self {
             get_physical_device_surface_present_modes2_ext: unsafe {
                 unsafe extern "system" fn get_physical_device_surface_present_modes2_ext(
                     _physical_device: PhysicalDevice,
@@ -18440,67 +14482,21 @@ impl ExtFullScreenExclusiveFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html>"]
-    pub unsafe fn get_physical_device_surface_present_modes2_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
-        p_present_mode_count: *mut u32,
-        p_present_modes: *mut PresentModeKHR,
-    ) -> Result {
-        (self.get_physical_device_surface_present_modes2_ext)(
-            physical_device,
-            p_surface_info,
-            p_present_mode_count,
-            p_present_modes,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireFullScreenExclusiveModeEXT.html>"]
-    pub unsafe fn acquire_full_screen_exclusive_mode_ext(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-    ) -> Result {
-        (self.acquire_full_screen_exclusive_mode_ext)(device, swapchain)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkReleaseFullScreenExclusiveModeEXT.html>"]
-    pub unsafe fn release_full_screen_exclusive_mode_ext(
-        &self,
-        device: Device,
-        swapchain: SwapchainKHR,
-    ) -> Result {
-        (self.release_full_screen_exclusive_mode_ext)(device, swapchain)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html>"]
-    pub unsafe fn get_device_group_surface_present_modes2_ext(
-        &self,
-        device: Device,
-        p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
-        p_modes: *mut DeviceGroupPresentModeFlagsKHR,
-    ) -> Result {
-        (self.get_device_group_surface_present_modes2_ext)(device, p_surface_info, p_modes)
-    }
-}
-#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"]
-impl StructureType {
-    pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1_000_255_000);
-}
-#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"]
-impl StructureType {
-    pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: Self = Self(1_000_255_002);
 }
 #[doc = "Generated from 'VK_EXT_full_screen_exclusive'"]
 impl Result {
-    pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: Self = Self(-1000255000);
+    pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: Self = Self(-1_000_255_000);
 }
 #[doc = "Generated from 'VK_EXT_full_screen_exclusive'"]
 impl StructureType {
+    pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1_000_255_000);
+    pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: Self = Self(1_000_255_002);
     pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: Self = Self(1_000_255_001);
 }
 impl ExtHeadlessSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_headless_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_headless_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18522,7 +14518,7 @@ impl ExtHeadlessSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtHeadlessSurfaceFn {
+        Self {
             create_headless_surface_ext: unsafe {
                 unsafe extern "system" fn create_headless_surface_ext(
                     _instance: Instance,
@@ -18547,25 +14543,17 @@ impl ExtHeadlessSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateHeadlessSurfaceEXT.html>"]
-    pub unsafe fn create_headless_surface_ext(
-        &self,
-        instance: Instance,
-        p_create_info: *const HeadlessSurfaceCreateInfoEXT,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_headless_surface_ext)(instance, p_create_info, p_allocator, p_surface)
-    }
 }
 #[doc = "Generated from 'VK_EXT_headless_surface'"]
 impl StructureType {
     pub const HEADLESS_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_256_000);
 }
 impl KhrBufferDeviceAddressFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_buffer_device_address\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_buffer_device_address\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18590,7 +14578,7 @@ impl KhrBufferDeviceAddressFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrBufferDeviceAddressFn {
+        Self {
             get_buffer_device_address_khr: unsafe {
                 unsafe extern "system" fn get_buffer_device_address_khr(
                     _device: Device,
@@ -18653,69 +14641,18 @@ impl KhrBufferDeviceAddressFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferDeviceAddressKHR.html>"]
-    pub unsafe fn get_buffer_device_address_khr(
-        &self,
-        device: Device,
-        p_info: *const BufferDeviceAddressInfo,
-    ) -> DeviceAddress {
-        (self.get_buffer_device_address_khr)(device, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferOpaqueCaptureAddressKHR.html>"]
-    pub unsafe fn get_buffer_opaque_capture_address_khr(
-        &self,
-        device: Device,
-        p_info: *const BufferDeviceAddressInfo,
-    ) -> u64 {
-        (self.get_buffer_opaque_capture_address_khr)(device, p_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html>"]
-    pub unsafe fn get_device_memory_opaque_capture_address_khr(
-        &self,
-        device: Device,
-        p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
-    ) -> u64 {
-        (self.get_device_memory_opaque_capture_address_khr)(device, p_info)
-    }
 }
 #[doc = "Generated from 'VK_KHR_buffer_device_address'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: Self =
-        Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
-}
-#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
-impl StructureType {
-    pub const BUFFER_DEVICE_ADDRESS_INFO_KHR: Self = Self::BUFFER_DEVICE_ADDRESS_INFO;
-}
-#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
-impl StructureType {
-    pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: Self =
-        Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
-impl StructureType {
-    pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: Self =
-        Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
-}
-#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
-impl StructureType {
-    pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: Self =
-        Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
+impl BufferCreateFlags {
+    pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
 }
 #[doc = "Generated from 'VK_KHR_buffer_device_address'"]
 impl BufferUsageFlags {
     pub const SHADER_DEVICE_ADDRESS_KHR: Self = Self::SHADER_DEVICE_ADDRESS;
 }
 #[doc = "Generated from 'VK_KHR_buffer_device_address'"]
-impl BufferCreateFlags {
-    pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
-}
-#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
 impl MemoryAllocateFlags {
     pub const DEVICE_ADDRESS_KHR: Self = Self::DEVICE_ADDRESS;
-}
-#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
-impl MemoryAllocateFlags {
     pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
 }
 #[doc = "Generated from 'VK_KHR_buffer_device_address'"]
@@ -18723,10 +14660,22 @@ impl Result {
     pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: Self =
         Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
 }
+#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
+    pub const BUFFER_DEVICE_ADDRESS_INFO_KHR: Self = Self::BUFFER_DEVICE_ADDRESS_INFO;
+    pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: Self =
+        Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
+    pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: Self =
+        Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
+    pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: Self =
+        Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
+}
 impl ExtExtension259Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_259\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_259\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -18739,13 +14688,28 @@ impl ExtExtension259Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension259Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_EXT_extension_259'"]
+impl FormatFeatureFlags2 {
+    pub const RESERVED_44_EXT: Self =
+        Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const RESERVED_45_EXT: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_extension_259'"]
+impl ImageCreateFlags {
+    pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_extension_259'"]
+impl QueueFlags {
+    pub const RESERVED_9_EXT: Self = Self(0b10_0000_0000);
+}
 impl ExtLineRasterizationFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_line_rasterization\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_line_rasterization\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18766,7 +14730,7 @@ impl ExtLineRasterizationFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtLineRasterizationFn {
+        Self {
             cmd_set_line_stipple_ext: unsafe {
                 unsafe extern "system" fn cmd_set_line_stipple_ext(
                     _command_buffer: CommandBuffer,
@@ -18789,36 +14753,21 @@ impl ExtLineRasterizationFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetLineStippleEXT.html>"]
-    pub unsafe fn cmd_set_line_stipple_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        line_stipple_factor: u32,
-        line_stipple_pattern: u16,
-    ) {
-        (self.cmd_set_line_stipple_ext)(command_buffer, line_stipple_factor, line_stipple_pattern)
-    }
 }
 #[doc = "Generated from 'VK_EXT_line_rasterization'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: Self = Self(1_000_259_000);
+impl DynamicState {
+    pub const LINE_STIPPLE_EXT: Self = Self(1_000_259_000);
 }
 #[doc = "Generated from 'VK_EXT_line_rasterization'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: Self = Self(1_000_259_000);
     pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: Self = Self(1_000_259_001);
-}
-#[doc = "Generated from 'VK_EXT_line_rasterization'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_259_002);
 }
-#[doc = "Generated from 'VK_EXT_line_rasterization'"]
-impl DynamicState {
-    pub const LINE_STIPPLE_EXT: Self = Self(1_000_259_000);
-}
 impl ExtShaderAtomicFloatFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_atomic_float\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18831,7 +14780,7 @@ impl ExtShaderAtomicFloatFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtShaderAtomicFloatFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_shader_atomic_float'"]
@@ -18839,9 +14788,9 @@ impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: Self = Self(1_000_260_000);
 }
 impl ExtHostQueryResetFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_host_query_reset\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_host_query_reset\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18863,7 +14812,7 @@ impl ExtHostQueryResetFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtHostQueryResetFn {
+        Self {
             reset_query_pool_ext: unsafe {
                 unsafe extern "system" fn reset_query_pool_ext(
                     _device: Device,
@@ -18884,16 +14833,6 @@ impl ExtHostQueryResetFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetQueryPoolEXT.html>"]
-    pub unsafe fn reset_query_pool_ext(
-        &self,
-        device: Device,
-        query_pool: QueryPool,
-        first_query: u32,
-        query_count: u32,
-    ) {
-        (self.reset_query_pool_ext)(device, query_pool, first_query, query_count)
-    }
 }
 #[doc = "Generated from 'VK_EXT_host_query_reset'"]
 impl StructureType {
@@ -18901,9 +14840,9 @@ impl StructureType {
         Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
 }
 impl GgpExtension263Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_263\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_263\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -18916,13 +14855,13 @@ impl GgpExtension263Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GgpExtension263Fn {}
+        Self {}
     }
 }
 impl BrcmExtension264Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_BRCM_extension_264\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_264\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -18935,13 +14874,13 @@ impl BrcmExtension264Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        BrcmExtension264Fn {}
+        Self {}
     }
 }
 impl BrcmExtension265Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_BRCM_extension_265\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_265\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -18954,13 +14893,13 @@ impl BrcmExtension265Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        BrcmExtension265Fn {}
+        Self {}
     }
 }
 impl ExtIndexTypeUint8Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_index_type_uint8\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_index_type_uint8\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -18973,21 +14912,21 @@ impl ExtIndexTypeUint8Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtIndexTypeUint8Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_index_type_uint8'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: Self = Self(1_000_265_000);
-}
-#[doc = "Generated from 'VK_EXT_index_type_uint8'"]
 impl IndexType {
     pub const UINT8_EXT: Self = Self(1_000_265_000);
 }
+#[doc = "Generated from 'VK_EXT_index_type_uint8'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: Self = Self(1_000_265_000);
+}
 impl ExtExtension267Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_267\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_267\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -19000,39 +14939,41 @@ impl ExtExtension267Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension267Fn {}
+        Self {}
     }
 }
 impl ExtExtendedDynamicStateFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extended_dynamic_state\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetCullModeEXT =
+pub type PFN_vkCmdSetCullMode =
     unsafe extern "system" fn(command_buffer: CommandBuffer, cull_mode: CullModeFlags);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetFrontFaceEXT =
+pub type PFN_vkCmdSetFrontFace =
     unsafe extern "system" fn(command_buffer: CommandBuffer, front_face: FrontFace);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetPrimitiveTopologyEXT =
+pub type PFN_vkCmdSetPrimitiveTopology =
     unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_topology: PrimitiveTopology);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetViewportWithCountEXT = unsafe extern "system" fn(
+pub type PFN_vkCmdSetViewportWithCount = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     viewport_count: u32,
     p_viewports: *const Viewport,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetScissorWithCountEXT = unsafe extern "system" fn(
+pub type PFN_vkCmdSetScissorWithCount = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     scissor_count: u32,
     p_scissors: *const Rect2D,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdBindVertexBuffers2EXT = unsafe extern "system" fn(
+pub type PFN_vkCmdBindVertexBuffers2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     first_binding: u32,
     binding_count: u32,
@@ -19042,22 +14983,22 @@ pub type PFN_vkCmdBindVertexBuffers2EXT = unsafe extern "system" fn(
     p_strides: *const DeviceSize,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetDepthTestEnableEXT =
+pub type PFN_vkCmdSetDepthTestEnable =
     unsafe extern "system" fn(command_buffer: CommandBuffer, depth_test_enable: Bool32);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetDepthWriteEnableEXT =
+pub type PFN_vkCmdSetDepthWriteEnable =
     unsafe extern "system" fn(command_buffer: CommandBuffer, depth_write_enable: Bool32);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetDepthCompareOpEXT =
+pub type PFN_vkCmdSetDepthCompareOp =
     unsafe extern "system" fn(command_buffer: CommandBuffer, depth_compare_op: CompareOp);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetDepthBoundsTestEnableEXT =
+pub type PFN_vkCmdSetDepthBoundsTestEnable =
     unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bounds_test_enable: Bool32);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetStencilTestEnableEXT =
+pub type PFN_vkCmdSetStencilTestEnable =
     unsafe extern "system" fn(command_buffer: CommandBuffer, stencil_test_enable: Bool32);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetStencilOpEXT = unsafe extern "system" fn(
+pub type PFN_vkCmdSetStencilOp = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     face_mask: StencilFaceFlags,
     fail_op: StencilOp,
@@ -19067,18 +15008,18 @@ pub type PFN_vkCmdSetStencilOpEXT = unsafe extern "system" fn(
 );
 #[derive(Clone)]
 pub struct ExtExtendedDynamicStateFn {
-    pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullModeEXT,
-    pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFaceEXT,
-    pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopologyEXT,
-    pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCountEXT,
-    pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCountEXT,
-    pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2EXT,
-    pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnableEXT,
-    pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnableEXT,
-    pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOpEXT,
-    pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnableEXT,
-    pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnableEXT,
-    pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOpEXT,
+    pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullMode,
+    pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace,
+    pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopology,
+    pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCount,
+    pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCount,
+    pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2,
+    pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnable,
+    pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnable,
+    pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOp,
+    pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnable,
+    pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnable,
+    pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOp,
 }
 unsafe impl Send for ExtExtendedDynamicStateFn {}
 unsafe impl Sync for ExtExtendedDynamicStateFn {}
@@ -19087,7 +15028,7 @@ impl ExtExtendedDynamicStateFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtendedDynamicStateFn {
+        Self {
             cmd_set_cull_mode_ext: unsafe {
                 unsafe extern "system" fn cmd_set_cull_mode_ext(
                     _command_buffer: CommandBuffer,
@@ -19337,185 +15278,33 @@ impl ExtExtendedDynamicStateFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetCullModeEXT.html>"]
-    pub unsafe fn cmd_set_cull_mode_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        cull_mode: CullModeFlags,
-    ) {
-        (self.cmd_set_cull_mode_ext)(command_buffer, cull_mode)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetFrontFaceEXT.html>"]
-    pub unsafe fn cmd_set_front_face_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        front_face: FrontFace,
-    ) {
-        (self.cmd_set_front_face_ext)(command_buffer, front_face)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetPrimitiveTopologyEXT.html>"]
-    pub unsafe fn cmd_set_primitive_topology_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        primitive_topology: PrimitiveTopology,
-    ) {
-        (self.cmd_set_primitive_topology_ext)(command_buffer, primitive_topology)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetViewportWithCountEXT.html>"]
-    pub unsafe fn cmd_set_viewport_with_count_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        viewport_count: u32,
-        p_viewports: *const Viewport,
-    ) {
-        (self.cmd_set_viewport_with_count_ext)(command_buffer, viewport_count, p_viewports)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetScissorWithCountEXT.html>"]
-    pub unsafe fn cmd_set_scissor_with_count_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        scissor_count: u32,
-        p_scissors: *const Rect2D,
-    ) {
-        (self.cmd_set_scissor_with_count_ext)(command_buffer, scissor_count, p_scissors)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindVertexBuffers2EXT.html>"]
-    pub unsafe fn cmd_bind_vertex_buffers2_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        first_binding: u32,
-        binding_count: u32,
-        p_buffers: *const Buffer,
-        p_offsets: *const DeviceSize,
-        p_sizes: *const DeviceSize,
-        p_strides: *const DeviceSize,
-    ) {
-        (self.cmd_bind_vertex_buffers2_ext)(
-            command_buffer,
-            first_binding,
-            binding_count,
-            p_buffers,
-            p_offsets,
-            p_sizes,
-            p_strides,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthTestEnableEXT.html>"]
-    pub unsafe fn cmd_set_depth_test_enable_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        depth_test_enable: Bool32,
-    ) {
-        (self.cmd_set_depth_test_enable_ext)(command_buffer, depth_test_enable)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthWriteEnableEXT.html>"]
-    pub unsafe fn cmd_set_depth_write_enable_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        depth_write_enable: Bool32,
-    ) {
-        (self.cmd_set_depth_write_enable_ext)(command_buffer, depth_write_enable)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthCompareOpEXT.html>"]
-    pub unsafe fn cmd_set_depth_compare_op_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        depth_compare_op: CompareOp,
-    ) {
-        (self.cmd_set_depth_compare_op_ext)(command_buffer, depth_compare_op)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBoundsTestEnableEXT.html>"]
-    pub unsafe fn cmd_set_depth_bounds_test_enable_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        depth_bounds_test_enable: Bool32,
-    ) {
-        (self.cmd_set_depth_bounds_test_enable_ext)(command_buffer, depth_bounds_test_enable)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilTestEnableEXT.html>"]
-    pub unsafe fn cmd_set_stencil_test_enable_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        stencil_test_enable: Bool32,
-    ) {
-        (self.cmd_set_stencil_test_enable_ext)(command_buffer, stencil_test_enable)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilOpEXT.html>"]
-    pub unsafe fn cmd_set_stencil_op_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        face_mask: StencilFaceFlags,
-        fail_op: StencilOp,
-        pass_op: StencilOp,
-        depth_fail_op: StencilOp,
-        compare_op: CompareOp,
-    ) {
-        (self.cmd_set_stencil_op_ext)(
-            command_buffer,
-            face_mask,
-            fail_op,
-            pass_op,
-            depth_fail_op,
-            compare_op,
-        )
-    }
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_267_000);
 }
 #[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
 impl DynamicState {
-    pub const CULL_MODE_EXT: Self = Self(1_000_267_000);
+    pub const CULL_MODE_EXT: Self = Self::CULL_MODE;
+    pub const FRONT_FACE_EXT: Self = Self::FRONT_FACE;
+    pub const PRIMITIVE_TOPOLOGY_EXT: Self = Self::PRIMITIVE_TOPOLOGY;
+    pub const VIEWPORT_WITH_COUNT_EXT: Self = Self::VIEWPORT_WITH_COUNT;
+    pub const SCISSOR_WITH_COUNT_EXT: Self = Self::SCISSOR_WITH_COUNT;
+    pub const VERTEX_INPUT_BINDING_STRIDE_EXT: Self = Self::VERTEX_INPUT_BINDING_STRIDE;
+    pub const DEPTH_TEST_ENABLE_EXT: Self = Self::DEPTH_TEST_ENABLE;
+    pub const DEPTH_WRITE_ENABLE_EXT: Self = Self::DEPTH_WRITE_ENABLE;
+    pub const DEPTH_COMPARE_OP_EXT: Self = Self::DEPTH_COMPARE_OP;
+    pub const DEPTH_BOUNDS_TEST_ENABLE_EXT: Self = Self::DEPTH_BOUNDS_TEST_ENABLE;
+    pub const STENCIL_TEST_ENABLE_EXT: Self = Self::STENCIL_TEST_ENABLE;
+    pub const STENCIL_OP_EXT: Self = Self::STENCIL_OP;
 }
 #[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const FRONT_FACE_EXT: Self = Self(1_000_267_001);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const PRIMITIVE_TOPOLOGY_EXT: Self = Self(1_000_267_002);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const VIEWPORT_WITH_COUNT_EXT: Self = Self(1_000_267_003);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const SCISSOR_WITH_COUNT_EXT: Self = Self(1_000_267_004);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const VERTEX_INPUT_BINDING_STRIDE_EXT: Self = Self(1_000_267_005);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const DEPTH_TEST_ENABLE_EXT: Self = Self(1_000_267_006);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const DEPTH_WRITE_ENABLE_EXT: Self = Self(1_000_267_007);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const DEPTH_COMPARE_OP_EXT: Self = Self(1_000_267_008);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const DEPTH_BOUNDS_TEST_ENABLE_EXT: Self = Self(1_000_267_009);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const STENCIL_TEST_ENABLE_EXT: Self = Self(1_000_267_010);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
-impl DynamicState {
-    pub const STENCIL_OP_EXT: Self = Self(1_000_267_011);
+impl StructureType {
+    #[doc = "Not promoted to 1.3"]
+    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_267_000);
 }
 impl KhrDeferredHostOperationsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_deferred_host_operations\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_deferred_host_operations\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 4u32;
 }
@@ -19555,7 +15344,7 @@ impl KhrDeferredHostOperationsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrDeferredHostOperationsFn {
+        Self {
             create_deferred_operation_khr: unsafe {
                 unsafe extern "system" fn create_deferred_operation_khr(
                     _device: Device,
@@ -19660,48 +15449,6 @@ impl KhrDeferredHostOperationsFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDeferredOperationKHR.html>"]
-    pub unsafe fn create_deferred_operation_khr(
-        &self,
-        device: Device,
-        p_allocator: *const AllocationCallbacks,
-        p_deferred_operation: *mut DeferredOperationKHR,
-    ) -> Result {
-        (self.create_deferred_operation_khr)(device, p_allocator, p_deferred_operation)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDeferredOperationKHR.html>"]
-    pub unsafe fn destroy_deferred_operation_khr(
-        &self,
-        device: Device,
-        operation: DeferredOperationKHR,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_deferred_operation_khr)(device, operation, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html>"]
-    pub unsafe fn get_deferred_operation_max_concurrency_khr(
-        &self,
-        device: Device,
-        operation: DeferredOperationKHR,
-    ) -> u32 {
-        (self.get_deferred_operation_max_concurrency_khr)(device, operation)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeferredOperationResultKHR.html>"]
-    pub unsafe fn get_deferred_operation_result_khr(
-        &self,
-        device: Device,
-        operation: DeferredOperationKHR,
-    ) -> Result {
-        (self.get_deferred_operation_result_khr)(device, operation)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDeferredOperationJoinKHR.html>"]
-    pub unsafe fn deferred_operation_join_khr(
-        &self,
-        device: Device,
-        operation: DeferredOperationKHR,
-    ) -> Result {
-        (self.deferred_operation_join_khr)(device, operation)
-    }
 }
 #[doc = "Generated from 'VK_KHR_deferred_host_operations'"]
 impl ObjectType {
@@ -19710,23 +15457,18 @@ impl ObjectType {
 #[doc = "Generated from 'VK_KHR_deferred_host_operations'"]
 impl Result {
     pub const THREAD_IDLE_KHR: Self = Self(1_000_268_000);
-}
-#[doc = "Generated from 'VK_KHR_deferred_host_operations'"]
-impl Result {
     pub const THREAD_DONE_KHR: Self = Self(1_000_268_001);
-}
-#[doc = "Generated from 'VK_KHR_deferred_host_operations'"]
-impl Result {
     pub const OPERATION_DEFERRED_KHR: Self = Self(1_000_268_002);
-}
-#[doc = "Generated from 'VK_KHR_deferred_host_operations'"]
-impl Result {
     pub const OPERATION_NOT_DEFERRED_KHR: Self = Self(1_000_268_003);
 }
 impl KhrPipelineExecutablePropertiesFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_pipeline_executable_properties\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_pipeline_executable_properties\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -19766,7 +15508,7 @@ impl KhrPipelineExecutablePropertiesFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrPipelineExecutablePropertiesFn {
+        Self {
             get_pipeline_executable_properties_khr: unsafe {
                 unsafe extern "system" fn get_pipeline_executable_properties_khr(
                     _device: Device,
@@ -19835,89 +15577,26 @@ impl KhrPipelineExecutablePropertiesFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineExecutablePropertiesKHR.html>"]
-    pub unsafe fn get_pipeline_executable_properties_khr(
-        &self,
-        device: Device,
-        p_pipeline_info: *const PipelineInfoKHR,
-        p_executable_count: *mut u32,
-        p_properties: *mut PipelineExecutablePropertiesKHR,
-    ) -> Result {
-        (self.get_pipeline_executable_properties_khr)(
-            device,
-            p_pipeline_info,
-            p_executable_count,
-            p_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineExecutableStatisticsKHR.html>"]
-    pub unsafe fn get_pipeline_executable_statistics_khr(
-        &self,
-        device: Device,
-        p_executable_info: *const PipelineExecutableInfoKHR,
-        p_statistic_count: *mut u32,
-        p_statistics: *mut PipelineExecutableStatisticKHR,
-    ) -> Result {
-        (self.get_pipeline_executable_statistics_khr)(
-            device,
-            p_executable_info,
-            p_statistic_count,
-            p_statistics,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html>"]
-    pub unsafe fn get_pipeline_executable_internal_representations_khr(
-        &self,
-        device: Device,
-        p_executable_info: *const PipelineExecutableInfoKHR,
-        p_internal_representation_count: *mut u32,
-        p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR,
-    ) -> Result {
-        (self.get_pipeline_executable_internal_representations_khr)(
-            device,
-            p_executable_info,
-            p_internal_representation_count,
-            p_internal_representations,
-        )
-    }
 }
 #[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self =
-        Self(1_000_269_000);
+impl PipelineCreateFlags {
+    pub const CAPTURE_STATISTICS_KHR: Self = Self(0b100_0000);
+    pub const CAPTURE_INTERNAL_REPRESENTATIONS_KHR: Self = Self(0b1000_0000);
 }
 #[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self =
+        Self(1_000_269_000);
     pub const PIPELINE_INFO_KHR: Self = Self(1_000_269_001);
-}
-#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
-impl StructureType {
     pub const PIPELINE_EXECUTABLE_PROPERTIES_KHR: Self = Self(1_000_269_002);
-}
-#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
-impl StructureType {
     pub const PIPELINE_EXECUTABLE_INFO_KHR: Self = Self(1_000_269_003);
-}
-#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
-impl StructureType {
     pub const PIPELINE_EXECUTABLE_STATISTIC_KHR: Self = Self(1_000_269_004);
-}
-#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
-impl StructureType {
     pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: Self = Self(1_000_269_005);
 }
-#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
-impl PipelineCreateFlags {
-    pub const CAPTURE_STATISTICS_KHR: Self = Self(0b100_0000);
-}
-#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
-impl PipelineCreateFlags {
-    pub const CAPTURE_INTERNAL_REPRESENTATIONS_KHR: Self = Self(0b1000_0000);
-}
 impl IntelExtension271Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_271\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_271\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -19930,32 +15609,92 @@ impl IntelExtension271Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        IntelExtension271Fn {}
+        Self {}
     }
 }
-impl IntelExtension272Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_272\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_INTEL_extension_271'"]
+impl FormatFeatureFlags2 {
+    pub const RESERVED_46_EXT: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_INTEL_extension_271'"]
+impl ImageUsageFlags {
+    pub const RESERVED_22_EXT: Self = Self(0b100_0000_0000_0000_0000_0000);
+}
+impl KhrMapMemory2Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_map_memory2\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkMapMemory2KHR = unsafe extern "system" fn(
+    device: Device,
+    p_memory_map_info: *const MemoryMapInfoKHR,
+    pp_data: *mut *mut c_void,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkUnmapMemory2KHR = unsafe extern "system" fn(
+    device: Device,
+    p_memory_unmap_info: *const MemoryUnmapInfoKHR,
+) -> Result;
 #[derive(Clone)]
-pub struct IntelExtension272Fn {}
-unsafe impl Send for IntelExtension272Fn {}
-unsafe impl Sync for IntelExtension272Fn {}
-impl IntelExtension272Fn {
+pub struct KhrMapMemory2Fn {
+    pub map_memory2_khr: PFN_vkMapMemory2KHR,
+    pub unmap_memory2_khr: PFN_vkUnmapMemory2KHR,
+}
+unsafe impl Send for KhrMapMemory2Fn {}
+unsafe impl Sync for KhrMapMemory2Fn {}
+impl KhrMapMemory2Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        IntelExtension272Fn {}
+        Self {
+            map_memory2_khr: unsafe {
+                unsafe extern "system" fn map_memory2_khr(
+                    _device: Device,
+                    _p_memory_map_info: *const MemoryMapInfoKHR,
+                    _pp_data: *mut *mut c_void,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(map_memory2_khr)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMapMemory2KHR\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    map_memory2_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            unmap_memory2_khr: unsafe {
+                unsafe extern "system" fn unmap_memory2_khr(
+                    _device: Device,
+                    _p_memory_unmap_info: *const MemoryUnmapInfoKHR,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(unmap_memory2_khr)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUnmapMemory2KHR\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    unmap_memory2_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
+#[doc = "Generated from 'VK_KHR_map_memory2'"]
+impl StructureType {
+    pub const MEMORY_MAP_INFO_KHR: Self = Self(1_000_271_000);
+    pub const MEMORY_UNMAP_INFO_KHR: Self = Self(1_000_271_001);
+}
 impl IntelExtension273Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_INTEL_extension_273\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_273\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -19968,13 +15707,13 @@ impl IntelExtension273Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        IntelExtension273Fn {}
+        Self {}
     }
 }
 impl ExtShaderAtomicFloat2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_atomic_float2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float2\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -19987,55 +15726,108 @@ impl ExtShaderAtomicFloat2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtShaderAtomicFloat2Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_shader_atomic_float2'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1_000_273_000);
 }
-impl KhrExtension275Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_275\0")
-            .expect("Wrong extension string")
+impl ExtSurfaceMaintenance1Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_surface_maintenance1\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct KhrExtension275Fn {}
-unsafe impl Send for KhrExtension275Fn {}
-unsafe impl Sync for KhrExtension275Fn {}
-impl KhrExtension275Fn {
+pub struct ExtSurfaceMaintenance1Fn {}
+unsafe impl Send for ExtSurfaceMaintenance1Fn {}
+unsafe impl Sync for ExtSurfaceMaintenance1Fn {}
+impl ExtSurfaceMaintenance1Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension275Fn {}
+        Self {}
     }
 }
-impl KhrExtension276Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_276\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_EXT_surface_maintenance1'"]
+impl StructureType {
+    pub const SURFACE_PRESENT_MODE_EXT: Self = Self(1_000_274_000);
+    pub const SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: Self = Self(1_000_274_001);
+    pub const SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: Self = Self(1_000_274_002);
+}
+impl ExtSwapchainMaintenance1Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_maintenance1\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkReleaseSwapchainImagesEXT = unsafe extern "system" fn(
+    device: Device,
+    p_release_info: *const ReleaseSwapchainImagesInfoEXT,
+) -> Result;
 #[derive(Clone)]
-pub struct KhrExtension276Fn {}
-unsafe impl Send for KhrExtension276Fn {}
-unsafe impl Sync for KhrExtension276Fn {}
-impl KhrExtension276Fn {
+pub struct ExtSwapchainMaintenance1Fn {
+    pub release_swapchain_images_ext: PFN_vkReleaseSwapchainImagesEXT,
+}
+unsafe impl Send for ExtSwapchainMaintenance1Fn {}
+unsafe impl Sync for ExtSwapchainMaintenance1Fn {}
+impl ExtSwapchainMaintenance1Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension276Fn {}
+        Self {
+            release_swapchain_images_ext: unsafe {
+                unsafe extern "system" fn release_swapchain_images_ext(
+                    _device: Device,
+                    _p_release_info: *const ReleaseSwapchainImagesInfoEXT,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(release_swapchain_images_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkReleaseSwapchainImagesEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    release_swapchain_images_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
+#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: Self = Self(1_000_275_000);
+    pub const SWAPCHAIN_PRESENT_FENCE_INFO_EXT: Self = Self(1_000_275_001);
+    pub const SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: Self = Self(1_000_275_002);
+    pub const SWAPCHAIN_PRESENT_MODE_INFO_EXT: Self = Self(1_000_275_003);
+    pub const SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: Self = Self(1_000_275_004);
+    pub const RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: Self = Self(1_000_275_005);
+}
+#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"]
+impl SwapchainCreateFlagsKHR {
+    pub const DEFERRED_MEMORY_ALLOCATION_EXT: Self = Self(0b1000);
+}
 impl ExtShaderDemoteToHelperInvocationFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_shader_demote_to_helper_invocation\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_shader_demote_to_helper_invocation\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20048,18 +15840,20 @@ impl ExtShaderDemoteToHelperInvocationFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtShaderDemoteToHelperInvocationFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_shader_demote_to_helper_invocation'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: Self =
-        Self(1_000_276_000);
+        Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
 }
 impl NvDeviceGeneratedCommandsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_generated_commands\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_generated_commands\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -20117,7 +15911,7 @@ impl NvDeviceGeneratedCommandsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvDeviceGeneratedCommandsFn {
+        Self {
             get_generated_commands_memory_requirements_nv: unsafe {
                 unsafe extern "system" fn get_generated_commands_memory_requirements_nv(
                     _device: Device,
@@ -20247,132 +16041,41 @@ impl NvDeviceGeneratedCommandsFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html>"]
-    pub unsafe fn get_generated_commands_memory_requirements_nv(
-        &self,
-        device: Device,
-        p_info: *const GeneratedCommandsMemoryRequirementsInfoNV,
-        p_memory_requirements: *mut MemoryRequirements2,
-    ) {
-        (self.get_generated_commands_memory_requirements_nv)(device, p_info, p_memory_requirements)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPreprocessGeneratedCommandsNV.html>"]
-    pub unsafe fn cmd_preprocess_generated_commands_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        p_generated_commands_info: *const GeneratedCommandsInfoNV,
-    ) {
-        (self.cmd_preprocess_generated_commands_nv)(command_buffer, p_generated_commands_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdExecuteGeneratedCommandsNV.html>"]
-    pub unsafe fn cmd_execute_generated_commands_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        is_preprocessed: Bool32,
-        p_generated_commands_info: *const GeneratedCommandsInfoNV,
-    ) {
-        (self.cmd_execute_generated_commands_nv)(
-            command_buffer,
-            is_preprocessed,
-            p_generated_commands_info,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindPipelineShaderGroupNV.html>"]
-    pub unsafe fn cmd_bind_pipeline_shader_group_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        pipeline_bind_point: PipelineBindPoint,
-        pipeline: Pipeline,
-        group_index: u32,
-    ) {
-        (self.cmd_bind_pipeline_shader_group_nv)(
-            command_buffer,
-            pipeline_bind_point,
-            pipeline,
-            group_index,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateIndirectCommandsLayoutNV.html>"]
-    pub unsafe fn create_indirect_commands_layout_nv(
-        &self,
-        device: Device,
-        p_create_info: *const IndirectCommandsLayoutCreateInfoNV,
-        p_allocator: *const AllocationCallbacks,
-        p_indirect_commands_layout: *mut IndirectCommandsLayoutNV,
-    ) -> Result {
-        (self.create_indirect_commands_layout_nv)(
-            device,
-            p_create_info,
-            p_allocator,
-            p_indirect_commands_layout,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyIndirectCommandsLayoutNV.html>"]
-    pub unsafe fn destroy_indirect_commands_layout_nv(
-        &self,
-        device: Device,
-        indirect_commands_layout: IndirectCommandsLayoutNV,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_indirect_commands_layout_nv)(device, indirect_commands_layout, p_allocator)
-    }
 }
 #[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self(1_000_277_000);
+impl AccessFlags {
+    pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000);
+    pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl StructureType {
-    pub const GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_277_001);
+impl ObjectType {
+    pub const INDIRECT_COMMANDS_LAYOUT_NV: Self = Self(1_000_277_000);
 }
 #[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl StructureType {
-    pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: Self = Self(1_000_277_002);
+impl PipelineCreateFlags {
+    pub const INDIRECT_BINDABLE_NV: Self = Self(0b100_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl StructureType {
-    pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: Self = Self(1_000_277_003);
+impl PipelineStageFlags {
+    pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_NV_device_generated_commands'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self(1_000_277_000);
+    pub const GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_277_001);
+    pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: Self = Self(1_000_277_002);
+    pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: Self = Self(1_000_277_003);
     pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: Self = Self(1_000_277_004);
-}
-#[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl StructureType {
     pub const GENERATED_COMMANDS_INFO_NV: Self = Self(1_000_277_005);
-}
-#[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl StructureType {
     pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_277_006);
-}
-#[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: Self = Self(1_000_277_007);
 }
-#[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl PipelineCreateFlags {
-    pub const INDIRECT_BINDABLE_NV: Self = Self(0b100_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl PipelineStageFlags {
-    pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl AccessFlags {
-    pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl AccessFlags {
-    pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_NV_device_generated_commands'"]
-impl ObjectType {
-    pub const INDIRECT_COMMANDS_LAYOUT_NV: Self = Self(1_000_277_000);
-}
 impl NvInheritedViewportScissorFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_inherited_viewport_scissor\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_inherited_viewport_scissor\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20385,21 +16088,18 @@ impl NvInheritedViewportScissorFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvInheritedViewportScissorFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_inherited_viewport_scissor'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: Self = Self(1_000_278_000);
-}
-#[doc = "Generated from 'VK_NV_inherited_viewport_scissor'"]
-impl StructureType {
     pub const COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: Self = Self(1_000_278_001);
 }
 impl KhrExtension280Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_280\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_280\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -20412,13 +16112,15 @@ impl KhrExtension280Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension280Fn {}
+        Self {}
     }
 }
 impl KhrShaderIntegerDotProductFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_integer_dot_product\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_integer_dot_product\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20431,21 +16133,22 @@ impl KhrShaderIntegerDotProductFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderIntegerDotProductFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_shader_integer_dot_product'"]
 impl StructureType {
-    pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: Self = Self(1_000_280_000);
-}
-#[doc = "Generated from 'VK_KHR_shader_integer_dot_product'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: Self = Self(1_000_280_001);
+    pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
+    pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: Self =
+        Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
 }
 impl ExtTexelBufferAlignmentFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_texel_buffer_alignment\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_texel_buffer_alignment\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20458,23 +16161,24 @@ impl ExtTexelBufferAlignmentFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtTexelBufferAlignmentFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_texel_buffer_alignment'"]
 impl StructureType {
+    #[doc = "Not promoted to 1.3"]
     pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: Self = Self(1_000_281_000);
-}
-#[doc = "Generated from 'VK_EXT_texel_buffer_alignment'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: Self = Self(1_000_281_001);
+    pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: Self =
+        Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
 }
 impl QcomRenderPassTransformFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_render_pass_transform\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_transform\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 2u32;
+    pub const SPEC_VERSION: u32 = 3u32;
 }
 #[derive(Clone)]
 pub struct QcomRenderPassTransformFn {}
@@ -20485,26 +16189,23 @@ impl QcomRenderPassTransformFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomRenderPassTransformFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_QCOM_render_pass_transform'"]
-impl StructureType {
-    pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self =
-        Self(1_000_282_000);
+impl RenderPassCreateFlags {
+    pub const TRANSFORM_QCOM: Self = Self(0b10);
 }
 #[doc = "Generated from 'VK_QCOM_render_pass_transform'"]
 impl StructureType {
+    pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self =
+        Self(1_000_282_000);
     pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001);
 }
-#[doc = "Generated from 'VK_QCOM_render_pass_transform'"]
-impl RenderPassCreateFlags {
-    pub const TRANSFORM_QCOM: Self = Self(0b10);
-}
 impl ExtExtension284Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_284\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_284\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -20517,13 +16218,13 @@ impl ExtExtension284Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension284Fn {}
+        Self {}
     }
 }
 impl ExtDeviceMemoryReportFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_device_memory_report\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_memory_report\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -20536,25 +16237,19 @@ impl ExtDeviceMemoryReportFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDeviceMemoryReportFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_device_memory_report'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: Self = Self(1_000_284_000);
-}
-#[doc = "Generated from 'VK_EXT_device_memory_report'"]
-impl StructureType {
     pub const DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: Self = Self(1_000_284_001);
-}
-#[doc = "Generated from 'VK_EXT_device_memory_report'"]
-impl StructureType {
     pub const DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: Self = Self(1_000_284_002);
 }
 impl ExtAcquireDrmDisplayFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_acquire_drm_display\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_drm_display\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20583,7 +16278,7 @@ impl ExtAcquireDrmDisplayFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtAcquireDrmDisplayFn {
+        Self {
             acquire_drm_display_ext: unsafe {
                 unsafe extern "system" fn acquire_drm_display_ext(
                     _physical_device: PhysicalDevice,
@@ -20624,30 +16319,11 @@ impl ExtAcquireDrmDisplayFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireDrmDisplayEXT.html>"]
-    pub unsafe fn acquire_drm_display_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        drm_fd: i32,
-        display: DisplayKHR,
-    ) -> Result {
-        (self.acquire_drm_display_ext)(physical_device, drm_fd, display)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDrmDisplayEXT.html>"]
-    pub unsafe fn get_drm_display_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        drm_fd: i32,
-        connector_id: u32,
-        display: *mut DisplayKHR,
-    ) -> Result {
-        (self.get_drm_display_ext)(physical_device, drm_fd, connector_id, display)
-    }
 }
 impl ExtRobustness2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_robustness2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_robustness2\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20660,21 +16336,18 @@ impl ExtRobustness2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtRobustness2Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_robustness2'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: Self = Self(1_000_286_000);
-}
-#[doc = "Generated from 'VK_EXT_robustness2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: Self = Self(1_000_286_001);
 }
 impl ExtCustomBorderColorFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_custom_border_color\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_custom_border_color\0") }
     }
     pub const SPEC_VERSION: u32 = 12u32;
 }
@@ -20687,33 +16360,24 @@ impl ExtCustomBorderColorFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtCustomBorderColorFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_custom_border_color'"]
-impl StructureType {
-    pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: Self = Self(1_000_287_000);
+impl BorderColor {
+    pub const FLOAT_CUSTOM_EXT: Self = Self(1_000_287_003);
+    pub const INT_CUSTOM_EXT: Self = Self(1_000_287_004);
 }
 #[doc = "Generated from 'VK_EXT_custom_border_color'"]
 impl StructureType {
+    pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: Self = Self(1_000_287_000);
     pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: Self = Self(1_000_287_001);
-}
-#[doc = "Generated from 'VK_EXT_custom_border_color'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: Self = Self(1_000_287_002);
 }
-#[doc = "Generated from 'VK_EXT_custom_border_color'"]
-impl BorderColor {
-    pub const FLOAT_CUSTOM_EXT: Self = Self(1_000_287_003);
-}
-#[doc = "Generated from 'VK_EXT_custom_border_color'"]
-impl BorderColor {
-    pub const INT_CUSTOM_EXT: Self = Self(1_000_287_004);
-}
 impl ExtExtension289Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_289\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_289\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -20726,133 +16390,46 @@ impl ExtExtension289Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension289Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_extension_289'"]
 impl Format {
     pub const ASTC_3X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_000);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_3X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_001);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_3X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_002);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_4X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_003);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_4X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_004);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_4X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_005);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_4X4X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_006);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_4X4X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_007);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_4X4X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_008);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_4X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_009);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_4X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_010);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_4X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_011);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_5X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_012);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_5X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_013);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_5X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_014);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_5X5X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_015);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_5X5X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_016);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_5X5X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_017);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_5X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_018);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_5X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_019);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_5X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_020);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_6X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_021);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_6X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_022);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_6X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_023);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_6X6X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_024);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_6X6X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_025);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_6X6X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_026);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_6X6X6_UNORM_BLOCK_EXT: Self = Self(1_000_288_027);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_6X6X6_SRGB_BLOCK_EXT: Self = Self(1_000_288_028);
-}
-#[doc = "Generated from 'VK_EXT_extension_289'"]
-impl Format {
     pub const ASTC_6X6X6_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_029);
 }
 impl GoogleUserTypeFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_user_type\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_user_type\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20865,13 +16442,13 @@ impl GoogleUserTypeFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GoogleUserTypeFn {}
+        Self {}
     }
 }
 impl KhrPipelineLibraryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_pipeline_library\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_pipeline_library\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20884,7 +16461,7 @@ impl KhrPipelineLibraryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrPipelineLibraryFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_pipeline_library'"]
@@ -20896,9 +16473,9 @@ impl StructureType {
     pub const PIPELINE_LIBRARY_CREATE_INFO_KHR: Self = Self(1_000_290_000);
 }
 impl NvExtension292Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_292\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_292\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -20911,32 +16488,40 @@ impl NvExtension292Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension292Fn {}
+        Self {}
     }
 }
-impl NvExtension293Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_293\0")
-            .expect("Wrong extension string")
+impl NvPresentBarrierFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_present_barrier\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct NvExtension293Fn {}
-unsafe impl Send for NvExtension293Fn {}
-unsafe impl Sync for NvExtension293Fn {}
-impl NvExtension293Fn {
+pub struct NvPresentBarrierFn {}
+unsafe impl Send for NvPresentBarrierFn {}
+unsafe impl Sync for NvPresentBarrierFn {}
+impl NvPresentBarrierFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension293Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_NV_present_barrier'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: Self = Self(1_000_292_000);
+    pub const SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: Self = Self(1_000_292_001);
+    pub const SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: Self = Self(1_000_292_002);
+}
 impl KhrShaderNonSemanticInfoFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_non_semantic_info\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_non_semantic_info\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20949,13 +16534,13 @@ impl KhrShaderNonSemanticInfoFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderNonSemanticInfoFn {}
+        Self {}
     }
 }
 impl KhrPresentIdFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_present_id\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_id\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -20968,59 +16553,56 @@ impl KhrPresentIdFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrPresentIdFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_present_id'"]
 impl StructureType {
     pub const PRESENT_ID_KHR: Self = Self(1_000_294_000);
-}
-#[doc = "Generated from 'VK_KHR_present_id'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: Self = Self(1_000_294_001);
 }
 impl ExtPrivateDataFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_private_data\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_private_data\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
 #[allow(non_camel_case_types)]
-pub type PFN_vkCreatePrivateDataSlotEXT = unsafe extern "system" fn(
+pub type PFN_vkCreatePrivateDataSlot = unsafe extern "system" fn(
     device: Device,
-    p_create_info: *const PrivateDataSlotCreateInfoEXT,
+    p_create_info: *const PrivateDataSlotCreateInfo,
     p_allocator: *const AllocationCallbacks,
-    p_private_data_slot: *mut PrivateDataSlotEXT,
+    p_private_data_slot: *mut PrivateDataSlot,
 ) -> Result;
 #[allow(non_camel_case_types)]
-pub type PFN_vkDestroyPrivateDataSlotEXT = unsafe extern "system" fn(
+pub type PFN_vkDestroyPrivateDataSlot = unsafe extern "system" fn(
     device: Device,
-    private_data_slot: PrivateDataSlotEXT,
+    private_data_slot: PrivateDataSlot,
     p_allocator: *const AllocationCallbacks,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkSetPrivateDataEXT = unsafe extern "system" fn(
+pub type PFN_vkSetPrivateData = unsafe extern "system" fn(
     device: Device,
     object_type: ObjectType,
     object_handle: u64,
-    private_data_slot: PrivateDataSlotEXT,
+    private_data_slot: PrivateDataSlot,
     data: u64,
 ) -> Result;
 #[allow(non_camel_case_types)]
-pub type PFN_vkGetPrivateDataEXT = unsafe extern "system" fn(
+pub type PFN_vkGetPrivateData = unsafe extern "system" fn(
     device: Device,
     object_type: ObjectType,
     object_handle: u64,
-    private_data_slot: PrivateDataSlotEXT,
+    private_data_slot: PrivateDataSlot,
     p_data: *mut u64,
 );
 #[derive(Clone)]
 pub struct ExtPrivateDataFn {
-    pub create_private_data_slot_ext: PFN_vkCreatePrivateDataSlotEXT,
-    pub destroy_private_data_slot_ext: PFN_vkDestroyPrivateDataSlotEXT,
-    pub set_private_data_ext: PFN_vkSetPrivateDataEXT,
-    pub get_private_data_ext: PFN_vkGetPrivateDataEXT,
+    pub create_private_data_slot_ext: PFN_vkCreatePrivateDataSlot,
+    pub destroy_private_data_slot_ext: PFN_vkDestroyPrivateDataSlot,
+    pub set_private_data_ext: PFN_vkSetPrivateData,
+    pub get_private_data_ext: PFN_vkGetPrivateData,
 }
 unsafe impl Send for ExtPrivateDataFn {}
 unsafe impl Sync for ExtPrivateDataFn {}
@@ -21029,13 +16611,13 @@ impl ExtPrivateDataFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtPrivateDataFn {
+        Self {
             create_private_data_slot_ext: unsafe {
                 unsafe extern "system" fn create_private_data_slot_ext(
                     _device: Device,
-                    _p_create_info: *const PrivateDataSlotCreateInfoEXT,
+                    _p_create_info: *const PrivateDataSlotCreateInfo,
                     _p_allocator: *const AllocationCallbacks,
-                    _p_private_data_slot: *mut PrivateDataSlotEXT,
+                    _p_private_data_slot: *mut PrivateDataSlot,
                 ) -> Result {
                     panic!(concat!(
                         "Unable to load ",
@@ -21055,7 +16637,7 @@ impl ExtPrivateDataFn {
             destroy_private_data_slot_ext: unsafe {
                 unsafe extern "system" fn destroy_private_data_slot_ext(
                     _device: Device,
-                    _private_data_slot: PrivateDataSlotEXT,
+                    _private_data_slot: PrivateDataSlot,
                     _p_allocator: *const AllocationCallbacks,
                 ) {
                     panic!(concat!(
@@ -21078,7 +16660,7 @@ impl ExtPrivateDataFn {
                     _device: Device,
                     _object_type: ObjectType,
                     _object_handle: u64,
-                    _private_data_slot: PrivateDataSlotEXT,
+                    _private_data_slot: PrivateDataSlot,
                     _data: u64,
                 ) -> Result {
                     panic!(concat!("Unable to load ", stringify!(set_private_data_ext)))
@@ -21097,7 +16679,7 @@ impl ExtPrivateDataFn {
                     _device: Device,
                     _object_type: ObjectType,
                     _object_handle: u64,
-                    _private_data_slot: PrivateDataSlotEXT,
+                    _private_data_slot: PrivateDataSlot,
                     _p_data: *mut u64,
                 ) {
                     panic!(concat!("Unable to load ", stringify!(get_private_data_ext)))
@@ -21113,74 +16695,22 @@ impl ExtPrivateDataFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreatePrivateDataSlotEXT.html>"]
-    pub unsafe fn create_private_data_slot_ext(
-        &self,
-        device: Device,
-        p_create_info: *const PrivateDataSlotCreateInfoEXT,
-        p_allocator: *const AllocationCallbacks,
-        p_private_data_slot: *mut PrivateDataSlotEXT,
-    ) -> Result {
-        (self.create_private_data_slot_ext)(device, p_create_info, p_allocator, p_private_data_slot)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPrivateDataSlotEXT.html>"]
-    pub unsafe fn destroy_private_data_slot_ext(
-        &self,
-        device: Device,
-        private_data_slot: PrivateDataSlotEXT,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_private_data_slot_ext)(device, private_data_slot, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetPrivateDataEXT.html>"]
-    pub unsafe fn set_private_data_ext(
-        &self,
-        device: Device,
-        object_type: ObjectType,
-        object_handle: u64,
-        private_data_slot: PrivateDataSlotEXT,
-        data: u64,
-    ) -> Result {
-        (self.set_private_data_ext)(device, object_type, object_handle, private_data_slot, data)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPrivateDataEXT.html>"]
-    pub unsafe fn get_private_data_ext(
-        &self,
-        device: Device,
-        object_type: ObjectType,
-        object_handle: u64,
-        private_data_slot: PrivateDataSlotEXT,
-        p_data: *mut u64,
-    ) {
-        (self.get_private_data_ext)(
-            device,
-            object_type,
-            object_handle,
-            private_data_slot,
-            p_data,
-        )
-    }
-}
-#[doc = "Generated from 'VK_EXT_private_data'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: Self = Self(1_000_295_000);
 }
 #[doc = "Generated from 'VK_EXT_private_data'"]
-impl StructureType {
-    pub const DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: Self = Self(1_000_295_001);
+impl ObjectType {
+    pub const PRIVATE_DATA_SLOT_EXT: Self = Self::PRIVATE_DATA_SLOT;
 }
 #[doc = "Generated from 'VK_EXT_private_data'"]
 impl StructureType {
-    pub const PRIVATE_DATA_SLOT_CREATE_INFO_EXT: Self = Self(1_000_295_002);
-}
-#[doc = "Generated from 'VK_EXT_private_data'"]
-impl ObjectType {
-    pub const PRIVATE_DATA_SLOT_EXT: Self = Self(1_000_295_000);
+    pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: Self =
+        Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
+    pub const DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: Self = Self::DEVICE_PRIVATE_DATA_CREATE_INFO;
+    pub const PRIVATE_DATA_SLOT_CREATE_INFO_EXT: Self = Self::PRIVATE_DATA_SLOT_CREATE_INFO;
 }
 impl KhrExtension297Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_297\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_297\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21193,7 +16723,7 @@ impl KhrExtension297Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension297Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_extension_297'"]
@@ -21201,9 +16731,13 @@ impl PipelineShaderStageCreateFlags {
     pub const RESERVED_3_KHR: Self = Self(0b1000);
 }
 impl ExtPipelineCreationCacheControlFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pipeline_creation_cache_control\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_pipeline_creation_cache_control\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 3u32;
 }
@@ -21216,38 +16750,32 @@ impl ExtPipelineCreationCacheControlFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtPipelineCreationCacheControlFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: Self =
-        Self(1_000_297_000);
-}
-#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
-impl PipelineCreateFlags {
-    pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self(0b1_0000_0000);
+impl PipelineCacheCreateFlags {
+    pub const EXTERNALLY_SYNCHRONIZED_EXT: Self = Self::EXTERNALLY_SYNCHRONIZED;
 }
 #[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
 impl PipelineCreateFlags {
-    pub const EARLY_RETURN_ON_FAILURE_EXT: Self = Self(0b10_0000_0000);
-}
-#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
-impl Result {
-    pub const PIPELINE_COMPILE_REQUIRED_EXT: Self = Self(1_000_297_000);
+    pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED;
+    pub const EARLY_RETURN_ON_FAILURE_EXT: Self = Self::EARLY_RETURN_ON_FAILURE;
 }
 #[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
 impl Result {
-    pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED_EXT;
+    pub const PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED;
+    pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED;
 }
 #[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
-impl PipelineCacheCreateFlags {
-    pub const EXTERNALLY_SYNCHRONIZED_EXT: Self = Self(0b1);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: Self =
+        Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
 }
 impl KhrExtension299Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_299\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_299\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21260,27 +16788,15 @@ impl KhrExtension299Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension299Fn {}
+        Self {}
     }
 }
-#[doc = "Generated from 'VK_KHR_extension_299'"]
-impl MemoryHeapFlags {
-    pub const RESERVED_2_KHR: Self = Self(0b100);
-}
-#[doc = "Generated from 'VK_KHR_extension_299'"]
-impl PipelineCacheCreateFlags {
-    pub const RESERVED_1_KHR: Self = Self::RESERVED_1_EXT;
-}
-#[doc = "Generated from 'VK_KHR_extension_299'"]
-impl PipelineCacheCreateFlags {
-    pub const RESERVED_2_KHR: Self = Self(0b100);
-}
 impl KhrVideoEncodeQueueFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_video_encode_queue\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_encode_queue\0") }
     }
-    pub const SPEC_VERSION: u32 = 2u32;
+    pub const SPEC_VERSION: u32 = 8u32;
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn(
@@ -21298,7 +16814,7 @@ impl KhrVideoEncodeQueueFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrVideoEncodeQueueFn {
+        Self {
             cmd_encode_video_khr: unsafe {
                 unsafe extern "system" fn cmd_encode_video_khr(
                     _command_buffer: CommandBuffer,
@@ -21317,89 +16833,78 @@ impl KhrVideoEncodeQueueFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEncodeVideoKHR.html>"]
-    pub unsafe fn cmd_encode_video_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_encode_info: *const VideoEncodeInfoKHR,
-    ) {
-        (self.cmd_encode_video_khr)(command_buffer, p_encode_info)
-    }
-}
-#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl PipelineStageFlags2KHR {
-    pub const VIDEO_ENCODE: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl AccessFlags2KHR {
-    pub const VIDEO_ENCODE_READ: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl AccessFlags2KHR {
-    pub const VIDEO_ENCODE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1_000_299_000);
-}
-#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl StructureType {
-    pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001);
-}
-#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl QueueFlags {
-    pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000);
+impl AccessFlags2 {
+    pub const VIDEO_ENCODE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const VIDEO_ENCODE_WRITE_KHR: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
 impl BufferUsageFlags {
     pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b1000_0000_0000_0000);
+    pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b1_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl BufferUsageFlags {
-    pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b1_0000_0000_0000_0000);
+impl FormatFeatureFlags {
+    pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
+    pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl ImageUsageFlags {
-    pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b10_0000_0000_0000);
+impl FormatFeatureFlags2 {
+    pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
+    pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl ImageUsageFlags {
-    pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b100_0000_0000_0000);
+impl ImageLayout {
+    pub const VIDEO_ENCODE_DST_KHR: Self = Self(1_000_299_000);
+    pub const VIDEO_ENCODE_SRC_KHR: Self = Self(1_000_299_001);
+    pub const VIDEO_ENCODE_DPB_KHR: Self = Self(1_000_299_002);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
 impl ImageUsageFlags {
+    pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b10_0000_0000_0000);
+    pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b100_0000_0000_0000);
     pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl FormatFeatureFlags {
-    pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
+impl PipelineStageFlags2 {
+    pub const VIDEO_ENCODE_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl FormatFeatureFlags {
-    pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
+impl QueryType {
+    pub const VIDEO_ENCODE_FEEDBACK_KHR: Self = Self(1_000_299_000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl ImageLayout {
-    pub const VIDEO_ENCODE_DST_KHR: Self = Self(1_000_299_000);
+impl QueueFlags {
+    pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl ImageLayout {
-    pub const VIDEO_ENCODE_SRC_KHR: Self = Self(1_000_299_001);
+impl Result {
+    pub const ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: Self = Self(-1_000_299_000);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl ImageLayout {
-    pub const VIDEO_ENCODE_DPB_KHR: Self = Self(1_000_299_002);
+impl StructureType {
+    pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1_000_299_000);
+    pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001);
+    pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1_000_299_002);
+    pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1_000_299_003);
+    pub const VIDEO_ENCODE_USAGE_INFO_KHR: Self = Self(1_000_299_004);
+    pub const QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: Self = Self(1_000_299_005);
 }
 #[doc = "Generated from 'VK_KHR_video_encode_queue'"]
-impl QueryType {
-    pub const VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR: Self = Self(1_000_299_000);
+impl VideoCodingControlFlagsKHR {
+    pub const ENCODE_RATE_CONTROL: Self = Self(0b10);
+    pub const ENCODE_RATE_CONTROL_LAYER: Self = Self(0b100);
 }
 impl NvDeviceDiagnosticsConfigFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_device_diagnostics_config\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_diagnostics_config\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 1u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
 #[derive(Clone)]
 pub struct NvDeviceDiagnosticsConfigFn {}
@@ -21410,21 +16915,20 @@ impl NvDeviceDiagnosticsConfigFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvDeviceDiagnosticsConfigFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_device_diagnostics_config'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: Self = Self(1_000_300_000);
-}
-#[doc = "Generated from 'VK_NV_device_diagnostics_config'"]
-impl StructureType {
     pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: Self = Self(1_000_300_001);
 }
 impl QcomRenderPassStoreOpsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_render_pass_store_ops\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_store_ops\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -21437,17 +16941,17 @@ impl QcomRenderPassStoreOpsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomRenderPassStoreOpsFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_QCOM_render_pass_store_ops'"]
 impl AttachmentStoreOp {
-    pub const NONE_QCOM: Self = Self::NONE_EXT;
+    pub const NONE_QCOM: Self = Self::NONE;
 }
 impl QcomExtension303Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_303\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_303\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21460,13 +16964,13 @@ impl QcomExtension303Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomExtension303Fn {}
+        Self {}
     }
 }
 impl QcomExtension304Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_304\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_304\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21479,13 +16983,13 @@ impl QcomExtension304Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomExtension304Fn {}
+        Self {}
     }
 }
 impl QcomExtension305Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_305\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_305\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21498,13 +17002,13 @@ impl QcomExtension305Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomExtension305Fn {}
+        Self {}
     }
 }
 impl QcomExtension306Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_306\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_306\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21517,13 +17021,13 @@ impl QcomExtension306Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomExtension306Fn {}
+        Self {}
     }
 }
 impl QcomExtension307Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_307\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_307\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21536,13 +17040,13 @@ impl QcomExtension307Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomExtension307Fn {}
+        Self {}
     }
 }
 impl NvExtension308Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_308\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_308\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21555,32 +17059,13 @@ impl NvExtension308Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension308Fn {}
-    }
-}
-impl KhrExtension309Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_309\0")
-            .expect("Wrong extension string")
-    }
-    pub const SPEC_VERSION: u32 = 0u32;
-}
-#[derive(Clone)]
-pub struct KhrExtension309Fn {}
-unsafe impl Send for KhrExtension309Fn {}
-unsafe impl Sync for KhrExtension309Fn {}
-impl KhrExtension309Fn {
-    pub fn load<F>(mut _f: F) -> Self
-    where
-        F: FnMut(&::std::ffi::CStr) -> *const c_void,
-    {
-        KhrExtension309Fn {}
+        Self {}
     }
 }
 impl QcomExtension310Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_310\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_310\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21593,55 +17078,99 @@ impl QcomExtension310Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomExtension310Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_QCOM_extension_310'"]
 impl StructureType {
     pub const RESERVED_QCOM: Self = Self(1_000_309_000);
 }
-impl NvExtension311Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_311\0")
-            .expect("Wrong extension string")
+impl NvLowLatencyFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_low_latency\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct NvExtension311Fn {}
-unsafe impl Send for NvExtension311Fn {}
-unsafe impl Sync for NvExtension311Fn {}
-impl NvExtension311Fn {
+pub struct NvLowLatencyFn {}
+unsafe impl Send for NvLowLatencyFn {}
+unsafe impl Sync for NvLowLatencyFn {}
+impl NvLowLatencyFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension311Fn {}
+        Self {}
     }
 }
-impl ExtExtension312Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_312\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_NV_low_latency'"]
+impl StructureType {
+    pub const QUERY_LOW_LATENCY_SUPPORT_NV: Self = Self(1_000_310_000);
+}
+impl ExtMetalObjectsFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_objects\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkExportMetalObjectsEXT =
+    unsafe extern "system" fn(device: Device, p_metal_objects_info: *mut ExportMetalObjectsInfoEXT);
 #[derive(Clone)]
-pub struct ExtExtension312Fn {}
-unsafe impl Send for ExtExtension312Fn {}
-unsafe impl Sync for ExtExtension312Fn {}
-impl ExtExtension312Fn {
+pub struct ExtMetalObjectsFn {
+    pub export_metal_objects_ext: PFN_vkExportMetalObjectsEXT,
+}
+unsafe impl Send for ExtMetalObjectsFn {}
+unsafe impl Sync for ExtMetalObjectsFn {}
+impl ExtMetalObjectsFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension312Fn {}
+        Self {
+            export_metal_objects_ext: unsafe {
+                unsafe extern "system" fn export_metal_objects_ext(
+                    _device: Device,
+                    _p_metal_objects_info: *mut ExportMetalObjectsInfoEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(export_metal_objects_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkExportMetalObjectsEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    export_metal_objects_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
+#[doc = "Generated from 'VK_EXT_metal_objects'"]
+impl StructureType {
+    pub const EXPORT_METAL_OBJECT_CREATE_INFO_EXT: Self = Self(1_000_311_000);
+    pub const EXPORT_METAL_OBJECTS_INFO_EXT: Self = Self(1_000_311_001);
+    pub const EXPORT_METAL_DEVICE_INFO_EXT: Self = Self(1_000_311_002);
+    pub const EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: Self = Self(1_000_311_003);
+    pub const EXPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_004);
+    pub const IMPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_005);
+    pub const EXPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_006);
+    pub const IMPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_007);
+    pub const EXPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_008);
+    pub const IMPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_009);
+    pub const EXPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_010);
+    pub const IMPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_011);
+}
 impl ExtExtension313Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_313\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_313\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21654,13 +17183,13 @@ impl ExtExtension313Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension313Fn {}
+        Self {}
     }
 }
 impl AmdExtension314Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_314\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_314\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -21673,58 +17202,58 @@ impl AmdExtension314Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension314Fn {}
+        Self {}
     }
 }
 impl KhrSynchronization2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_synchronization2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_synchronization2\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetEvent2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdSetEvent2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     event: Event,
-    p_dependency_info: *const DependencyInfoKHR,
+    p_dependency_info: *const DependencyInfo,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdResetEvent2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdResetEvent2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     event: Event,
-    stage_mask: PipelineStageFlags2KHR,
+    stage_mask: PipelineStageFlags2,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdWaitEvents2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdWaitEvents2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     event_count: u32,
     p_events: *const Event,
-    p_dependency_infos: *const DependencyInfoKHR,
+    p_dependency_infos: *const DependencyInfo,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdPipelineBarrier2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdPipelineBarrier2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    p_dependency_info: *const DependencyInfoKHR,
+    p_dependency_info: *const DependencyInfo,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdWriteTimestamp2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdWriteTimestamp2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    stage: PipelineStageFlags2KHR,
+    stage: PipelineStageFlags2,
     query_pool: QueryPool,
     query: u32,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkQueueSubmit2KHR = unsafe extern "system" fn(
+pub type PFN_vkQueueSubmit2 = unsafe extern "system" fn(
     queue: Queue,
     submit_count: u32,
-    p_submits: *const SubmitInfo2KHR,
+    p_submits: *const SubmitInfo2,
     fence: Fence,
 ) -> Result;
 #[allow(non_camel_case_types)]
 pub type PFN_vkCmdWriteBufferMarker2AMD = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    stage: PipelineStageFlags2KHR,
+    stage: PipelineStageFlags2,
     dst_buffer: Buffer,
     dst_offset: DeviceSize,
     marker: u32,
@@ -21737,12 +17266,12 @@ pub type PFN_vkGetQueueCheckpointData2NV = unsafe extern "system" fn(
 );
 #[derive(Clone)]
 pub struct KhrSynchronization2Fn {
-    pub cmd_set_event2_khr: PFN_vkCmdSetEvent2KHR,
-    pub cmd_reset_event2_khr: PFN_vkCmdResetEvent2KHR,
-    pub cmd_wait_events2_khr: PFN_vkCmdWaitEvents2KHR,
-    pub cmd_pipeline_barrier2_khr: PFN_vkCmdPipelineBarrier2KHR,
-    pub cmd_write_timestamp2_khr: PFN_vkCmdWriteTimestamp2KHR,
-    pub queue_submit2_khr: PFN_vkQueueSubmit2KHR,
+    pub cmd_set_event2_khr: PFN_vkCmdSetEvent2,
+    pub cmd_reset_event2_khr: PFN_vkCmdResetEvent2,
+    pub cmd_wait_events2_khr: PFN_vkCmdWaitEvents2,
+    pub cmd_pipeline_barrier2_khr: PFN_vkCmdPipelineBarrier2,
+    pub cmd_write_timestamp2_khr: PFN_vkCmdWriteTimestamp2,
+    pub queue_submit2_khr: PFN_vkQueueSubmit2,
     pub cmd_write_buffer_marker2_amd: PFN_vkCmdWriteBufferMarker2AMD,
     pub get_queue_checkpoint_data2_nv: PFN_vkGetQueueCheckpointData2NV,
 }
@@ -21753,12 +17282,12 @@ impl KhrSynchronization2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrSynchronization2Fn {
+        Self {
             cmd_set_event2_khr: unsafe {
                 unsafe extern "system" fn cmd_set_event2_khr(
                     _command_buffer: CommandBuffer,
                     _event: Event,
-                    _p_dependency_info: *const DependencyInfoKHR,
+                    _p_dependency_info: *const DependencyInfo,
                 ) {
                     panic!(concat!("Unable to load ", stringify!(cmd_set_event2_khr)))
                 }
@@ -21774,7 +17303,7 @@ impl KhrSynchronization2Fn {
                 unsafe extern "system" fn cmd_reset_event2_khr(
                     _command_buffer: CommandBuffer,
                     _event: Event,
-                    _stage_mask: PipelineStageFlags2KHR,
+                    _stage_mask: PipelineStageFlags2,
                 ) {
                     panic!(concat!("Unable to load ", stringify!(cmd_reset_event2_khr)))
                 }
@@ -21792,7 +17321,7 @@ impl KhrSynchronization2Fn {
                     _command_buffer: CommandBuffer,
                     _event_count: u32,
                     _p_events: *const Event,
-                    _p_dependency_infos: *const DependencyInfoKHR,
+                    _p_dependency_infos: *const DependencyInfo,
                 ) {
                     panic!(concat!("Unable to load ", stringify!(cmd_wait_events2_khr)))
                 }
@@ -21808,7 +17337,7 @@ impl KhrSynchronization2Fn {
             cmd_pipeline_barrier2_khr: unsafe {
                 unsafe extern "system" fn cmd_pipeline_barrier2_khr(
                     _command_buffer: CommandBuffer,
-                    _p_dependency_info: *const DependencyInfoKHR,
+                    _p_dependency_info: *const DependencyInfo,
                 ) {
                     panic!(concat!(
                         "Unable to load ",
@@ -21827,7 +17356,7 @@ impl KhrSynchronization2Fn {
             cmd_write_timestamp2_khr: unsafe {
                 unsafe extern "system" fn cmd_write_timestamp2_khr(
                     _command_buffer: CommandBuffer,
-                    _stage: PipelineStageFlags2KHR,
+                    _stage: PipelineStageFlags2,
                     _query_pool: QueryPool,
                     _query: u32,
                 ) {
@@ -21849,7 +17378,7 @@ impl KhrSynchronization2Fn {
                 unsafe extern "system" fn queue_submit2_khr(
                     _queue: Queue,
                     _submit_count: u32,
-                    _p_submits: *const SubmitInfo2KHR,
+                    _p_submits: *const SubmitInfo2,
                     _fence: Fence,
                 ) -> Result {
                     panic!(concat!("Unable to load ", stringify!(queue_submit2_khr)))
@@ -21865,7 +17394,7 @@ impl KhrSynchronization2Fn {
             cmd_write_buffer_marker2_amd: unsafe {
                 unsafe extern "system" fn cmd_write_buffer_marker2_amd(
                     _command_buffer: CommandBuffer,
-                    _stage: PipelineStageFlags2KHR,
+                    _stage: PipelineStageFlags2,
                     _dst_buffer: Buffer,
                     _dst_offset: DeviceSize,
                     _marker: u32,
@@ -21908,252 +17437,80 @@ impl KhrSynchronization2Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetEvent2KHR.html>"]
-    pub unsafe fn cmd_set_event2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        event: Event,
-        p_dependency_info: *const DependencyInfoKHR,
-    ) {
-        (self.cmd_set_event2_khr)(command_buffer, event, p_dependency_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetEvent2KHR.html>"]
-    pub unsafe fn cmd_reset_event2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        event: Event,
-        stage_mask: PipelineStageFlags2KHR,
-    ) {
-        (self.cmd_reset_event2_khr)(command_buffer, event, stage_mask)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWaitEvents2KHR.html>"]
-    pub unsafe fn cmd_wait_events2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        event_count: u32,
-        p_events: *const Event,
-        p_dependency_infos: *const DependencyInfoKHR,
-    ) {
-        (self.cmd_wait_events2_khr)(command_buffer, event_count, p_events, p_dependency_infos)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPipelineBarrier2KHR.html>"]
-    pub unsafe fn cmd_pipeline_barrier2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_dependency_info: *const DependencyInfoKHR,
-    ) {
-        (self.cmd_pipeline_barrier2_khr)(command_buffer, p_dependency_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp2KHR.html>"]
-    pub unsafe fn cmd_write_timestamp2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        stage: PipelineStageFlags2KHR,
-        query_pool: QueryPool,
-        query: u32,
-    ) {
-        (self.cmd_write_timestamp2_khr)(command_buffer, stage, query_pool, query)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueSubmit2KHR.html>"]
-    pub unsafe fn queue_submit2_khr(
-        &self,
-        queue: Queue,
-        submit_count: u32,
-        p_submits: *const SubmitInfo2KHR,
-        fence: Fence,
-    ) -> Result {
-        (self.queue_submit2_khr)(queue, submit_count, p_submits, fence)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteBufferMarker2AMD.html>"]
-    pub unsafe fn cmd_write_buffer_marker2_amd(
-        &self,
-        command_buffer: CommandBuffer,
-        stage: PipelineStageFlags2KHR,
-        dst_buffer: Buffer,
-        dst_offset: DeviceSize,
-        marker: u32,
-    ) {
-        (self.cmd_write_buffer_marker2_amd)(command_buffer, stage, dst_buffer, dst_offset, marker)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetQueueCheckpointData2NV.html>"]
-    pub unsafe fn get_queue_checkpoint_data2_nv(
-        &self,
-        queue: Queue,
-        p_checkpoint_data_count: *mut u32,
-        p_checkpoint_data: *mut CheckpointData2NV,
-    ) {
-        (self.get_queue_checkpoint_data2_nv)(queue, p_checkpoint_data_count, p_checkpoint_data)
-    }
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl StructureType {
-    pub const MEMORY_BARRIER_2_KHR: Self = Self(1_000_314_000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl StructureType {
-    pub const BUFFER_MEMORY_BARRIER_2_KHR: Self = Self(1_000_314_001);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl StructureType {
-    pub const IMAGE_MEMORY_BARRIER_2_KHR: Self = Self(1_000_314_002);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl StructureType {
-    pub const DEPENDENCY_INFO_KHR: Self = Self(1_000_314_003);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl StructureType {
-    pub const SUBMIT_INFO_2_KHR: Self = Self(1_000_314_004);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl StructureType {
-    pub const SEMAPHORE_SUBMIT_INFO_KHR: Self = Self(1_000_314_005);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl StructureType {
-    pub const COMMAND_BUFFER_SUBMIT_INFO_KHR: Self = Self(1_000_314_006);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: Self = Self(1_000_314_007);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl EventCreateFlags {
-    pub const DEVICE_ONLY_KHR: Self = Self(0b1);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl ImageLayout {
-    pub const READ_ONLY_OPTIMAL_KHR: Self = Self(1_000_314_000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl ImageLayout {
-    pub const ATTACHMENT_OPTIMAL_KHR: Self = Self(1_000_314_001);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags {
-    pub const NONE_KHR: Self = Self(0);
 }
 #[doc = "Generated from 'VK_KHR_synchronization2'"]
 impl AccessFlags {
-    pub const NONE_KHR: Self = Self(0);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+    pub const NONE_KHR: Self = Self::NONE;
 }
 #[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
+impl AccessFlags2 {
     pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
     pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
     pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self =
         Self(0b1000_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
+    #[doc = "read access flag for reading conditional rendering predicate"]
     pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
     pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
     pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000);
+    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self =
+        Self(0b1000_0000_0000_0000_0000_0000);
+    pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR;
+    pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
+    pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR;
+    pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR;
+    pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+    pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(0b100_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
-    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ: Self = Self(0b1000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT;
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
-    pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ;
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const ACCELERATION_STRUCTURE_BUILD: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
-    pub const ACCELERATION_STRUCTURE_READ: Self = Self(0b10_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
-    pub const ACCELERATION_STRUCTURE_WRITE: Self = Self(0b100_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const RAY_TRACING_SHADER: Self = Self(0b10_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER;
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD;
+impl EventCreateFlags {
+    pub const DEVICE_ONLY_KHR: Self = Self::DEVICE_ONLY;
 }
 #[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
-    pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ;
+impl ImageLayout {
+    pub const READ_ONLY_OPTIMAL_KHR: Self = Self::READ_ONLY_OPTIMAL;
+    pub const ATTACHMENT_OPTIMAL_KHR: Self = Self::ATTACHMENT_OPTIMAL;
 }
 #[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
-    pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE;
+impl PipelineStageFlags {
+    pub const NONE_KHR: Self = Self::NONE;
 }
 #[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
+impl PipelineStageFlags2 {
+    pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+    #[doc = "A pipeline stage for conditional rendering predicate fetch"]
+    pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000);
+    pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000);
+    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR;
+    pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
+    pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
+    pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR;
+    pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR;
     pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
-    pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl AccessFlags2KHR {
-    pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const TASK_SHADER_NV: Self = Self(0b1000_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl PipelineStageFlags2KHR {
-    pub const MESH_SHADER_NV: Self = Self(0b1_0000_0000_0000_0000_0000);
+    pub const TASK_SHADER_NV: Self = Self::TASK_SHADER_EXT;
+    pub const MESH_SHADER_NV: Self = Self::MESH_SHADER_EXT;
+    pub const TASK_SHADER_EXT: Self = Self(0b1000_0000_0000_0000_0000);
+    pub const MESH_SHADER_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_KHR_synchronization2'"]
 impl StructureType {
+    pub const MEMORY_BARRIER_2_KHR: Self = Self::MEMORY_BARRIER_2;
+    pub const BUFFER_MEMORY_BARRIER_2_KHR: Self = Self::BUFFER_MEMORY_BARRIER_2;
+    pub const IMAGE_MEMORY_BARRIER_2_KHR: Self = Self::IMAGE_MEMORY_BARRIER_2;
+    pub const DEPENDENCY_INFO_KHR: Self = Self::DEPENDENCY_INFO;
+    pub const SUBMIT_INFO_2_KHR: Self = Self::SUBMIT_INFO_2;
+    pub const SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::SEMAPHORE_SUBMIT_INFO;
+    pub const COMMAND_BUFFER_SUBMIT_INFO_KHR: Self = Self::COMMAND_BUFFER_SUBMIT_INFO;
+    pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
     pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: Self = Self(1_000_314_008);
-}
-#[doc = "Generated from 'VK_KHR_synchronization2'"]
-impl StructureType {
     pub const CHECKPOINT_DATA_2_NV: Self = Self(1_000_314_009);
 }
 impl AmdExtension316Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_316\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_316\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -22166,32 +17523,417 @@ impl AmdExtension316Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension316Fn {}
+        Self {}
     }
 }
-impl AmdExtension317Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_317\0")
-            .expect("Wrong extension string")
+impl ExtDescriptorBufferFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_buffer\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn(
+    device: Device,
+    layout: DescriptorSetLayout,
+    p_layout_size_in_bytes: *mut DeviceSize,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn(
+    device: Device,
+    layout: DescriptorSetLayout,
+    binding: u32,
+    p_offset: *mut DeviceSize,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDescriptorEXT = unsafe extern "system" fn(
+    device: Device,
+    p_descriptor_info: *const DescriptorGetInfoEXT,
+    data_size: usize,
+    p_descriptor: *mut c_void,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    buffer_count: u32,
+    p_binding_infos: *const DescriptorBufferBindingInfoEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    pipeline_bind_point: PipelineBindPoint,
+    layout: PipelineLayout,
+    first_set: u32,
+    set_count: u32,
+    p_buffer_indices: *const u32,
+    p_offsets: *const DeviceSize,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    pipeline_bind_point: PipelineBindPoint,
+    layout: PipelineLayout,
+    set: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(
+    device: Device,
+    p_info: *const BufferCaptureDescriptorDataInfoEXT,
+    p_data: *mut c_void,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(
+    device: Device,
+    p_info: *const ImageCaptureDescriptorDataInfoEXT,
+    p_data: *mut c_void,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(
+    device: Device,
+    p_info: *const ImageViewCaptureDescriptorDataInfoEXT,
+    p_data: *mut c_void,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(
+    device: Device,
+    p_info: *const SamplerCaptureDescriptorDataInfoEXT,
+    p_data: *mut c_void,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT =
+    unsafe extern "system" fn(
+        device: Device,
+        p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT,
+        p_data: *mut c_void,
+    ) -> Result;
 #[derive(Clone)]
-pub struct AmdExtension317Fn {}
-unsafe impl Send for AmdExtension317Fn {}
-unsafe impl Sync for AmdExtension317Fn {}
-impl AmdExtension317Fn {
-    pub fn load<F>(mut _f: F) -> Self
-    where
-        F: FnMut(&::std::ffi::CStr) -> *const c_void,
-    {
-        AmdExtension317Fn {}
+pub struct ExtDescriptorBufferFn {
+    pub get_descriptor_set_layout_size_ext: PFN_vkGetDescriptorSetLayoutSizeEXT,
+    pub get_descriptor_set_layout_binding_offset_ext: PFN_vkGetDescriptorSetLayoutBindingOffsetEXT,
+    pub get_descriptor_ext: PFN_vkGetDescriptorEXT,
+    pub cmd_bind_descriptor_buffers_ext: PFN_vkCmdBindDescriptorBuffersEXT,
+    pub cmd_set_descriptor_buffer_offsets_ext: PFN_vkCmdSetDescriptorBufferOffsetsEXT,
+    pub cmd_bind_descriptor_buffer_embedded_samplers_ext:
+        PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
+    pub get_buffer_opaque_capture_descriptor_data_ext:
+        PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT,
+    pub get_image_opaque_capture_descriptor_data_ext: PFN_vkGetImageOpaqueCaptureDescriptorDataEXT,
+    pub get_image_view_opaque_capture_descriptor_data_ext:
+        PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
+    pub get_sampler_opaque_capture_descriptor_data_ext:
+        PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
+    pub get_acceleration_structure_opaque_capture_descriptor_data_ext:
+        PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
+}
+unsafe impl Send for ExtDescriptorBufferFn {}
+unsafe impl Sync for ExtDescriptorBufferFn {}
+impl ExtDescriptorBufferFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            get_descriptor_set_layout_size_ext: unsafe {
+                unsafe extern "system" fn get_descriptor_set_layout_size_ext(
+                    _device: Device,
+                    _layout: DescriptorSetLayout,
+                    _p_layout_size_in_bytes: *mut DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_descriptor_set_layout_size_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDescriptorSetLayoutSizeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_descriptor_set_layout_size_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_descriptor_set_layout_binding_offset_ext: unsafe {
+                unsafe extern "system" fn get_descriptor_set_layout_binding_offset_ext(
+                    _device: Device,
+                    _layout: DescriptorSetLayout,
+                    _binding: u32,
+                    _p_offset: *mut DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_descriptor_set_layout_binding_offset_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDescriptorSetLayoutBindingOffsetEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_descriptor_set_layout_binding_offset_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_descriptor_ext: unsafe {
+                unsafe extern "system" fn get_descriptor_ext(
+                    _device: Device,
+                    _p_descriptor_info: *const DescriptorGetInfoEXT,
+                    _data_size: usize,
+                    _p_descriptor: *mut c_void,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(get_descriptor_ext)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDescriptorEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_descriptor_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_descriptor_buffers_ext: unsafe {
+                unsafe extern "system" fn cmd_bind_descriptor_buffers_ext(
+                    _command_buffer: CommandBuffer,
+                    _buffer_count: u32,
+                    _p_binding_infos: *const DescriptorBufferBindingInfoEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_bind_descriptor_buffers_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdBindDescriptorBuffersEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_descriptor_buffers_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_descriptor_buffer_offsets_ext: unsafe {
+                unsafe extern "system" fn cmd_set_descriptor_buffer_offsets_ext(
+                    _command_buffer: CommandBuffer,
+                    _pipeline_bind_point: PipelineBindPoint,
+                    _layout: PipelineLayout,
+                    _first_set: u32,
+                    _set_count: u32,
+                    _p_buffer_indices: *const u32,
+                    _p_offsets: *const DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_descriptor_buffer_offsets_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDescriptorBufferOffsetsEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_descriptor_buffer_offsets_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_descriptor_buffer_embedded_samplers_ext: unsafe {
+                unsafe extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers_ext(
+                    _command_buffer: CommandBuffer,
+                    _pipeline_bind_point: PipelineBindPoint,
+                    _layout: PipelineLayout,
+                    _set: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_bind_descriptor_buffer_embedded_samplers_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdBindDescriptorBufferEmbeddedSamplersEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_descriptor_buffer_embedded_samplers_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_buffer_opaque_capture_descriptor_data_ext: unsafe {
+                unsafe extern "system" fn get_buffer_opaque_capture_descriptor_data_ext(
+                    _device: Device,
+                    _p_info: *const BufferCaptureDescriptorDataInfoEXT,
+                    _p_data: *mut c_void,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_buffer_opaque_capture_descriptor_data_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetBufferOpaqueCaptureDescriptorDataEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_buffer_opaque_capture_descriptor_data_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_image_opaque_capture_descriptor_data_ext: unsafe {
+                unsafe extern "system" fn get_image_opaque_capture_descriptor_data_ext(
+                    _device: Device,
+                    _p_info: *const ImageCaptureDescriptorDataInfoEXT,
+                    _p_data: *mut c_void,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_image_opaque_capture_descriptor_data_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetImageOpaqueCaptureDescriptorDataEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_image_opaque_capture_descriptor_data_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_image_view_opaque_capture_descriptor_data_ext: unsafe {
+                unsafe extern "system" fn get_image_view_opaque_capture_descriptor_data_ext(
+                    _device: Device,
+                    _p_info: *const ImageViewCaptureDescriptorDataInfoEXT,
+                    _p_data: *mut c_void,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_image_view_opaque_capture_descriptor_data_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetImageViewOpaqueCaptureDescriptorDataEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_image_view_opaque_capture_descriptor_data_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_sampler_opaque_capture_descriptor_data_ext: unsafe {
+                unsafe extern "system" fn get_sampler_opaque_capture_descriptor_data_ext(
+                    _device: Device,
+                    _p_info: *const SamplerCaptureDescriptorDataInfoEXT,
+                    _p_data: *mut c_void,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_sampler_opaque_capture_descriptor_data_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetSamplerOpaqueCaptureDescriptorDataEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_sampler_opaque_capture_descriptor_data_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_acceleration_structure_opaque_capture_descriptor_data_ext: unsafe {
+                unsafe extern "system" fn get_acceleration_structure_opaque_capture_descriptor_data_ext(
+                    _device: Device,
+                    _p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT,
+                    _p_data: *mut c_void,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_acceleration_structure_opaque_capture_descriptor_data_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_acceleration_structure_opaque_capture_descriptor_data_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl AccelerationStructureCreateFlagsKHR {
+    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000);
+}
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl AccessFlags2 {
+    pub const DESCRIPTOR_BUFFER_READ_EXT: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl BufferCreateFlags {
+    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b10_0000);
+}
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl BufferUsageFlags {
+    pub const SAMPLER_DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000);
+    pub const RESOURCE_DESCRIPTOR_BUFFER_EXT: Self = Self(0b100_0000_0000_0000_0000_0000);
+    pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl DescriptorSetLayoutCreateFlags {
+    pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b1_0000);
+    pub const EMBEDDED_IMMUTABLE_SAMPLERS_EXT: Self = Self(0b10_0000);
+}
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl ImageCreateFlags {
+    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl ImageViewCreateFlags {
+    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b100);
+}
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl PipelineCreateFlags {
+    pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl SamplerCreateFlags {
+    pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000);
+}
+#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: Self = Self(1_000_316_000);
+    pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: Self =
+        Self(1_000_316_001);
+    pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: Self = Self(1_000_316_002);
+    pub const DESCRIPTOR_ADDRESS_INFO_EXT: Self = Self(1_000_316_003);
+    pub const DESCRIPTOR_GET_INFO_EXT: Self = Self(1_000_316_004);
+    pub const BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_005);
+    pub const IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_006);
+    pub const IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_007);
+    pub const SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_008);
+    pub const OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: Self = Self(1_000_316_010);
+    pub const DESCRIPTOR_BUFFER_BINDING_INFO_EXT: Self = Self(1_000_316_011);
+    pub const DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: Self =
+        Self(1_000_316_012);
+    pub const ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_009);
+}
 impl AmdExtension318Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_318\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_318\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -22204,13 +17946,13 @@ impl AmdExtension318Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension318Fn {}
+        Self {}
     }
 }
 impl AmdExtension319Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_319\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_319\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -22223,7 +17965,7 @@ impl AmdExtension319Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension319Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_AMD_extension_319'"]
@@ -22235,9 +17977,9 @@ impl PipelineLayoutCreateFlags {
     pub const RESERVED_0_AMD: Self = Self(0b1);
 }
 impl AmdExtension320Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_320\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_320\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -22250,78 +17992,108 @@ impl AmdExtension320Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension320Fn {}
+        Self {}
     }
 }
-impl AmdExtension321Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_321\0")
-            .expect("Wrong extension string")
+impl ExtGraphicsPipelineLibraryFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_graphics_pipeline_library\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct AmdExtension321Fn {}
-unsafe impl Send for AmdExtension321Fn {}
-unsafe impl Sync for AmdExtension321Fn {}
-impl AmdExtension321Fn {
+pub struct ExtGraphicsPipelineLibraryFn {}
+unsafe impl Send for ExtGraphicsPipelineLibraryFn {}
+unsafe impl Sync for ExtGraphicsPipelineLibraryFn {}
+impl ExtGraphicsPipelineLibraryFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension321Fn {}
+        Self {}
     }
 }
-#[doc = "Generated from 'VK_AMD_extension_321'"]
+#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"]
 impl PipelineCreateFlags {
-    pub const RESERVED_23_AMD: Self = Self(0b1000_0000_0000_0000_0000_0000);
+    pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
+    pub const LINK_TIME_OPTIMIZATION_EXT: Self = Self(0b100_0000_0000);
 }
-#[doc = "Generated from 'VK_AMD_extension_321'"]
-impl PipelineCreateFlags {
-    pub const RESERVED_10_AMD: Self = Self(0b100_0000_0000);
+#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"]
+impl PipelineLayoutCreateFlags {
+    pub const INDEPENDENT_SETS_EXT: Self = Self(0b10);
 }
-impl AmdExtension322Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_322\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: Self = Self(1_000_320_000);
+    pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: Self = Self(1_000_320_001);
+    pub const GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: Self = Self(1_000_320_002);
+}
+impl AmdShaderEarlyAndLateFragmentTestsFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_AMD_shader_early_and_late_fragment_tests\0",
+            )
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct AmdExtension322Fn {}
-unsafe impl Send for AmdExtension322Fn {}
-unsafe impl Sync for AmdExtension322Fn {}
-impl AmdExtension322Fn {
+pub struct AmdShaderEarlyAndLateFragmentTestsFn {}
+unsafe impl Send for AmdShaderEarlyAndLateFragmentTestsFn {}
+unsafe impl Sync for AmdShaderEarlyAndLateFragmentTestsFn {}
+impl AmdShaderEarlyAndLateFragmentTestsFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension322Fn {}
+        Self {}
     }
 }
-impl AmdExtension323Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_AMD_extension_323\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_AMD_shader_early_and_late_fragment_tests'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: Self =
+        Self(1_000_321_000);
+}
+impl KhrFragmentShaderBarycentricFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shader_barycentric\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct AmdExtension323Fn {}
-unsafe impl Send for AmdExtension323Fn {}
-unsafe impl Sync for AmdExtension323Fn {}
-impl AmdExtension323Fn {
+pub struct KhrFragmentShaderBarycentricFn {}
+unsafe impl Send for KhrFragmentShaderBarycentricFn {}
+unsafe impl Sync for KhrFragmentShaderBarycentricFn {}
+impl KhrFragmentShaderBarycentricFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        AmdExtension323Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_KHR_fragment_shader_barycentric'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: Self = Self(1_000_203_000);
+    pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: Self =
+        Self(1_000_322_000);
+}
 impl KhrShaderSubgroupUniformControlFlowFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_shader_subgroup_uniform_control_flow\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_shader_subgroup_uniform_control_flow\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -22334,7 +18106,7 @@ impl KhrShaderSubgroupUniformControlFlowFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrShaderSubgroupUniformControlFlowFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_shader_subgroup_uniform_control_flow'"]
@@ -22343,9 +18115,9 @@ impl StructureType {
         Self(1_000_323_000);
 }
 impl KhrExtension325Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_325\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_325\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -22358,13 +18130,17 @@ impl KhrExtension325Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension325Fn {}
+        Self {}
     }
 }
 impl KhrZeroInitializeWorkgroupMemoryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_zero_initialize_workgroup_memory\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_zero_initialize_workgroup_memory\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -22377,18 +18153,20 @@ impl KhrZeroInitializeWorkgroupMemoryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrZeroInitializeWorkgroupMemoryFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_zero_initialize_workgroup_memory'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: Self =
-        Self(1_000_325_000);
+        Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
 }
 impl NvFragmentShadingRateEnumsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_fragment_shading_rate_enums\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shading_rate_enums\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -22396,7 +18174,7 @@ impl NvFragmentShadingRateEnumsFn {
 pub type PFN_vkCmdSetFragmentShadingRateEnumNV = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
     shading_rate: FragmentShadingRateNV,
-    combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
+    combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
 );
 #[derive(Clone)]
 pub struct NvFragmentShadingRateEnumsFn {
@@ -22409,12 +18187,12 @@ impl NvFragmentShadingRateEnumsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvFragmentShadingRateEnumsFn {
+        Self {
             cmd_set_fragment_shading_rate_enum_nv: unsafe {
                 unsafe extern "system" fn cmd_set_fragment_shading_rate_enum_nv(
                     _command_buffer: CommandBuffer,
                     _shading_rate: FragmentShadingRateNV,
-                    _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
+                    _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
                 ) {
                     panic!(concat!(
                         "Unable to load ",
@@ -22433,32 +18211,19 @@ impl NvFragmentShadingRateEnumsFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetFragmentShadingRateEnumNV.html>"]
-    pub unsafe fn cmd_set_fragment_shading_rate_enum_nv(
-        &self,
-        command_buffer: CommandBuffer,
-        shading_rate: FragmentShadingRateNV,
-        combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
-    ) {
-        (self.cmd_set_fragment_shading_rate_enum_nv)(command_buffer, shading_rate, combiner_ops)
-    }
 }
 #[doc = "Generated from 'VK_NV_fragment_shading_rate_enums'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: Self = Self(1_000_326_000);
-}
-#[doc = "Generated from 'VK_NV_fragment_shading_rate_enums'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: Self = Self(1_000_326_001);
-}
-#[doc = "Generated from 'VK_NV_fragment_shading_rate_enums'"]
-impl StructureType {
     pub const PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: Self = Self(1_000_326_002);
 }
 impl NvRayTracingMotionBlurFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_ray_tracing_motion_blur\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing_motion_blur\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -22471,56 +18236,177 @@ impl NvRayTracingMotionBlurFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvRayTracingMotionBlurFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: Self = Self(1_000_327_000);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: Self = Self(1_000_327_001);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
-impl StructureType {
-    pub const ACCELERATION_STRUCTURE_MOTION_INFO_NV: Self = Self(1_000_327_002);
+impl AccelerationStructureCreateFlagsKHR {
+    pub const MOTION_NV: Self = Self(0b100);
 }
 #[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
 impl BuildAccelerationStructureFlagsKHR {
     pub const MOTION_NV: Self = Self(0b10_0000);
 }
 #[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
-impl AccelerationStructureCreateFlagsKHR {
-    pub const MOTION_NV: Self = Self(0b100);
-}
-#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
 impl PipelineCreateFlags {
     pub const RAY_TRACING_ALLOW_MOTION_NV: Self = Self(0b1_0000_0000_0000_0000_0000);
 }
-impl NvExtension329Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_329\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
+impl StructureType {
+    pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: Self = Self(1_000_327_000);
+    pub const PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: Self = Self(1_000_327_001);
+    pub const ACCELERATION_STRUCTURE_MOTION_INFO_NV: Self = Self(1_000_327_002);
+}
+impl ExtMeshShaderFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_mesh_shader\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDrawMeshTasksEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    group_count_x: u32,
+    group_count_y: u32,
+    group_count_z: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDrawMeshTasksIndirectEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    buffer: Buffer,
+    offset: DeviceSize,
+    draw_count: u32,
+    stride: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDrawMeshTasksIndirectCountEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    buffer: Buffer,
+    offset: DeviceSize,
+    count_buffer: Buffer,
+    count_buffer_offset: DeviceSize,
+    max_draw_count: u32,
+    stride: u32,
+);
 #[derive(Clone)]
-pub struct NvExtension329Fn {}
-unsafe impl Send for NvExtension329Fn {}
-unsafe impl Sync for NvExtension329Fn {}
-impl NvExtension329Fn {
+pub struct ExtMeshShaderFn {
+    pub cmd_draw_mesh_tasks_ext: PFN_vkCmdDrawMeshTasksEXT,
+    pub cmd_draw_mesh_tasks_indirect_ext: PFN_vkCmdDrawMeshTasksIndirectEXT,
+    pub cmd_draw_mesh_tasks_indirect_count_ext: PFN_vkCmdDrawMeshTasksIndirectCountEXT,
+}
+unsafe impl Send for ExtMeshShaderFn {}
+unsafe impl Sync for ExtMeshShaderFn {}
+impl ExtMeshShaderFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension329Fn {}
+        Self {
+            cmd_draw_mesh_tasks_ext: unsafe {
+                unsafe extern "system" fn cmd_draw_mesh_tasks_ext(
+                    _command_buffer: CommandBuffer,
+                    _group_count_x: u32,
+                    _group_count_y: u32,
+                    _group_count_z: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_draw_mesh_tasks_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_mesh_tasks_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_draw_mesh_tasks_indirect_ext: unsafe {
+                unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_ext(
+                    _command_buffer: CommandBuffer,
+                    _buffer: Buffer,
+                    _offset: DeviceSize,
+                    _draw_count: u32,
+                    _stride: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_draw_mesh_tasks_indirect_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdDrawMeshTasksIndirectEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_mesh_tasks_indirect_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_draw_mesh_tasks_indirect_count_ext: unsafe {
+                unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_ext(
+                    _command_buffer: CommandBuffer,
+                    _buffer: Buffer,
+                    _offset: DeviceSize,
+                    _count_buffer: Buffer,
+                    _count_buffer_offset: DeviceSize,
+                    _max_draw_count: u32,
+                    _stride: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_draw_mesh_tasks_indirect_count_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdDrawMeshTasksIndirectCountEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_mesh_tasks_indirect_count_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
+#[doc = "Generated from 'VK_EXT_mesh_shader'"]
+impl IndirectCommandsTokenTypeNV {
+    pub const DRAW_MESH_TASKS: Self = Self(1_000_328_000);
+}
+#[doc = "Generated from 'VK_EXT_mesh_shader'"]
+impl PipelineStageFlags {
+    pub const TASK_SHADER_EXT: Self = Self(0b1000_0000_0000_0000_0000);
+    pub const MESH_SHADER_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_mesh_shader'"]
+impl QueryPipelineStatisticFlags {
+    pub const TASK_SHADER_INVOCATIONS_EXT: Self = Self(0b1000_0000_0000);
+    pub const MESH_SHADER_INVOCATIONS_EXT: Self = Self(0b1_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_mesh_shader'"]
+impl QueryType {
+    pub const MESH_PRIMITIVES_GENERATED_EXT: Self = Self(1_000_328_000);
+}
+#[doc = "Generated from 'VK_EXT_mesh_shader'"]
+impl ShaderStageFlags {
+    pub const TASK_EXT: Self = Self(0b100_0000);
+    pub const MESH_EXT: Self = Self(0b1000_0000);
+}
+#[doc = "Generated from 'VK_EXT_mesh_shader'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: Self = Self(1_000_328_000);
+    pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: Self = Self(1_000_328_001);
+}
 impl NvExtension330Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_330\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_330\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -22533,13 +18419,15 @@ impl NvExtension330Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension330Fn {}
+        Self {}
     }
 }
 impl ExtYcbcr2plane444FormatsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_ycbcr_2plane_444_formats\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_2plane_444_formats\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -22552,33 +18440,26 @@ impl ExtYcbcr2plane444FormatsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtYcbcr2plane444FormatsFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: Self = Self(1_000_330_000);
-}
-#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"]
 impl Format {
-    pub const G8_B8R8_2PLANE_444_UNORM_EXT: Self = Self(1_000_330_000);
+    pub const G8_B8R8_2PLANE_444_UNORM_EXT: Self = Self::G8_B8R8_2PLANE_444_UNORM;
+    pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: Self =
+        Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16;
+    pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: Self =
+        Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16;
+    pub const G16_B16R16_2PLANE_444_UNORM_EXT: Self = Self::G16_B16R16_2PLANE_444_UNORM;
 }
 #[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"]
-impl Format {
-    pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: Self = Self(1_000_330_001);
-}
-#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"]
-impl Format {
-    pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: Self = Self(1_000_330_002);
-}
-#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"]
-impl Format {
-    pub const G16_B16R16_2PLANE_444_UNORM_EXT: Self = Self(1_000_330_003);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: Self = Self(1_000_330_000);
 }
 impl NvExtension332Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_332\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_332\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -22591,13 +18472,15 @@ impl NvExtension332Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension332Fn {}
+        Self {}
     }
 }
 impl ExtFragmentDensityMap2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_fragment_density_map2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map2\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -22610,25 +18493,24 @@ impl ExtFragmentDensityMap2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtFragmentDensityMap2Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_fragment_density_map2'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: Self = Self(1_000_332_000);
+impl ImageViewCreateFlags {
+    pub const FRAGMENT_DENSITY_MAP_DEFERRED_EXT: Self = Self(0b10);
 }
 #[doc = "Generated from 'VK_EXT_fragment_density_map2'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: Self = Self(1_000_332_000);
     pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: Self = Self(1_000_332_001);
 }
-#[doc = "Generated from 'VK_EXT_fragment_density_map2'"]
-impl ImageViewCreateFlags {
-    pub const FRAGMENT_DENSITY_MAP_DEFERRED_EXT: Self = Self(0b10);
-}
 impl QcomRotatedCopyCommandsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_rotated_copy_commands\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_rotated_copy_commands\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -22641,7 +18523,7 @@ impl QcomRotatedCopyCommandsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomRotatedCopyCommandsFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_QCOM_rotated_copy_commands'"]
@@ -22649,9 +18531,9 @@ impl StructureType {
     pub const COPY_COMMAND_TRANSFORM_INFO_QCOM: Self = Self(1_000_333_000);
 }
 impl KhrExtension335Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_335\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_335\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -22664,13 +18546,13 @@ impl KhrExtension335Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension335Fn {}
+        Self {}
     }
 }
 impl ExtImageRobustnessFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_image_robustness\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_robustness\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -22683,17 +18565,22 @@ impl ExtImageRobustnessFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtImageRobustnessFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_image_robustness'"]
 impl StructureType {
-    pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: Self = Self(1_000_335_000);
+    pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: Self =
+        Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
 }
 impl KhrWorkgroupMemoryExplicitLayoutFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_workgroup_memory_explicit_layout\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_KHR_workgroup_memory_explicit_layout\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -22706,7 +18593,7 @@ impl KhrWorkgroupMemoryExplicitLayoutFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrWorkgroupMemoryExplicitLayoutFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_KHR_workgroup_memory_explicit_layout'"]
@@ -22715,50 +18602,50 @@ impl StructureType {
         Self(1_000_336_000);
 }
 impl KhrCopyCommands2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_copy_commands2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_copy_commands2\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdCopyBuffer2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdCopyBuffer2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    p_copy_buffer_info: *const CopyBufferInfo2KHR,
+    p_copy_buffer_info: *const CopyBufferInfo2,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdCopyImage2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdCopyImage2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    p_copy_image_info: *const CopyImageInfo2KHR,
+    p_copy_image_info: *const CopyImageInfo2,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdCopyBufferToImage2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdCopyBufferToImage2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2KHR,
+    p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdCopyImageToBuffer2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdCopyImageToBuffer2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2KHR,
+    p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdBlitImage2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdBlitImage2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    p_blit_image_info: *const BlitImageInfo2KHR,
+    p_blit_image_info: *const BlitImageInfo2,
 );
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdResolveImage2KHR = unsafe extern "system" fn(
+pub type PFN_vkCmdResolveImage2 = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
-    p_resolve_image_info: *const ResolveImageInfo2KHR,
+    p_resolve_image_info: *const ResolveImageInfo2,
 );
 #[derive(Clone)]
 pub struct KhrCopyCommands2Fn {
-    pub cmd_copy_buffer2_khr: PFN_vkCmdCopyBuffer2KHR,
-    pub cmd_copy_image2_khr: PFN_vkCmdCopyImage2KHR,
-    pub cmd_copy_buffer_to_image2_khr: PFN_vkCmdCopyBufferToImage2KHR,
-    pub cmd_copy_image_to_buffer2_khr: PFN_vkCmdCopyImageToBuffer2KHR,
-    pub cmd_blit_image2_khr: PFN_vkCmdBlitImage2KHR,
-    pub cmd_resolve_image2_khr: PFN_vkCmdResolveImage2KHR,
+    pub cmd_copy_buffer2_khr: PFN_vkCmdCopyBuffer2,
+    pub cmd_copy_image2_khr: PFN_vkCmdCopyImage2,
+    pub cmd_copy_buffer_to_image2_khr: PFN_vkCmdCopyBufferToImage2,
+    pub cmd_copy_image_to_buffer2_khr: PFN_vkCmdCopyImageToBuffer2,
+    pub cmd_blit_image2_khr: PFN_vkCmdBlitImage2,
+    pub cmd_resolve_image2_khr: PFN_vkCmdResolveImage2,
 }
 unsafe impl Send for KhrCopyCommands2Fn {}
 unsafe impl Sync for KhrCopyCommands2Fn {}
@@ -22767,11 +18654,11 @@ impl KhrCopyCommands2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrCopyCommands2Fn {
+        Self {
             cmd_copy_buffer2_khr: unsafe {
                 unsafe extern "system" fn cmd_copy_buffer2_khr(
                     _command_buffer: CommandBuffer,
-                    _p_copy_buffer_info: *const CopyBufferInfo2KHR,
+                    _p_copy_buffer_info: *const CopyBufferInfo2,
                 ) {
                     panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2_khr)))
                 }
@@ -22787,7 +18674,7 @@ impl KhrCopyCommands2Fn {
             cmd_copy_image2_khr: unsafe {
                 unsafe extern "system" fn cmd_copy_image2_khr(
                     _command_buffer: CommandBuffer,
-                    _p_copy_image_info: *const CopyImageInfo2KHR,
+                    _p_copy_image_info: *const CopyImageInfo2,
                 ) {
                     panic!(concat!("Unable to load ", stringify!(cmd_copy_image2_khr)))
                 }
@@ -22803,7 +18690,7 @@ impl KhrCopyCommands2Fn {
             cmd_copy_buffer_to_image2_khr: unsafe {
                 unsafe extern "system" fn cmd_copy_buffer_to_image2_khr(
                     _command_buffer: CommandBuffer,
-                    _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2KHR,
+                    _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2,
                 ) {
                     panic!(concat!(
                         "Unable to load ",
@@ -22823,7 +18710,7 @@ impl KhrCopyCommands2Fn {
             cmd_copy_image_to_buffer2_khr: unsafe {
                 unsafe extern "system" fn cmd_copy_image_to_buffer2_khr(
                     _command_buffer: CommandBuffer,
-                    _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2KHR,
+                    _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2,
                 ) {
                     panic!(concat!(
                         "Unable to load ",
@@ -22843,7 +18730,7 @@ impl KhrCopyCommands2Fn {
             cmd_blit_image2_khr: unsafe {
                 unsafe extern "system" fn cmd_blit_image2_khr(
                     _command_buffer: CommandBuffer,
-                    _p_blit_image_info: *const BlitImageInfo2KHR,
+                    _p_blit_image_info: *const BlitImageInfo2,
                 ) {
                     panic!(concat!("Unable to load ", stringify!(cmd_blit_image2_khr)))
                 }
@@ -22859,7 +18746,7 @@ impl KhrCopyCommands2Fn {
             cmd_resolve_image2_khr: unsafe {
                 unsafe extern "system" fn cmd_resolve_image2_khr(
                     _command_buffer: CommandBuffer,
-                    _p_resolve_image_info: *const ResolveImageInfo2KHR,
+                    _p_resolve_image_info: *const ResolveImageInfo2,
                 ) {
                     panic!(concat!(
                         "Unable to load ",
@@ -22877,145 +18764,137 @@ impl KhrCopyCommands2Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBuffer2KHR.html>"]
-    pub unsafe fn cmd_copy_buffer2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_copy_buffer_info: *const CopyBufferInfo2KHR,
-    ) {
-        (self.cmd_copy_buffer2_khr)(command_buffer, p_copy_buffer_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImage2KHR.html>"]
-    pub unsafe fn cmd_copy_image2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_copy_image_info: *const CopyImageInfo2KHR,
-    ) {
-        (self.cmd_copy_image2_khr)(command_buffer, p_copy_image_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBufferToImage2KHR.html>"]
-    pub unsafe fn cmd_copy_buffer_to_image2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2KHR,
-    ) {
-        (self.cmd_copy_buffer_to_image2_khr)(command_buffer, p_copy_buffer_to_image_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImageToBuffer2KHR.html>"]
-    pub unsafe fn cmd_copy_image_to_buffer2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2KHR,
-    ) {
-        (self.cmd_copy_image_to_buffer2_khr)(command_buffer, p_copy_image_to_buffer_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBlitImage2KHR.html>"]
-    pub unsafe fn cmd_blit_image2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_blit_image_info: *const BlitImageInfo2KHR,
-    ) {
-        (self.cmd_blit_image2_khr)(command_buffer, p_blit_image_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResolveImage2KHR.html>"]
-    pub unsafe fn cmd_resolve_image2_khr(
-        &self,
-        command_buffer: CommandBuffer,
-        p_resolve_image_info: *const ResolveImageInfo2KHR,
-    ) {
-        (self.cmd_resolve_image2_khr)(command_buffer, p_resolve_image_info)
-    }
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const COPY_BUFFER_INFO_2_KHR: Self = Self(1_000_337_000);
 }
 #[doc = "Generated from 'VK_KHR_copy_commands2'"]
 impl StructureType {
-    pub const COPY_IMAGE_INFO_2_KHR: Self = Self(1_000_337_001);
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const COPY_BUFFER_TO_IMAGE_INFO_2_KHR: Self = Self(1_000_337_002);
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const COPY_IMAGE_TO_BUFFER_INFO_2_KHR: Self = Self(1_000_337_003);
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const BLIT_IMAGE_INFO_2_KHR: Self = Self(1_000_337_004);
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const RESOLVE_IMAGE_INFO_2_KHR: Self = Self(1_000_337_005);
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const BUFFER_COPY_2_KHR: Self = Self(1_000_337_006);
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const IMAGE_COPY_2_KHR: Self = Self(1_000_337_007);
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const IMAGE_BLIT_2_KHR: Self = Self(1_000_337_008);
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const BUFFER_IMAGE_COPY_2_KHR: Self = Self(1_000_337_009);
-}
-#[doc = "Generated from 'VK_KHR_copy_commands2'"]
-impl StructureType {
-    pub const IMAGE_RESOLVE_2_KHR: Self = Self(1_000_337_010);
-}
-impl ArmExtension339Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_339\0")
-            .expect("Wrong extension string")
+    pub const COPY_BUFFER_INFO_2_KHR: Self = Self::COPY_BUFFER_INFO_2;
+    pub const COPY_IMAGE_INFO_2_KHR: Self = Self::COPY_IMAGE_INFO_2;
+    pub const COPY_BUFFER_TO_IMAGE_INFO_2_KHR: Self = Self::COPY_BUFFER_TO_IMAGE_INFO_2;
+    pub const COPY_IMAGE_TO_BUFFER_INFO_2_KHR: Self = Self::COPY_IMAGE_TO_BUFFER_INFO_2;
+    pub const BLIT_IMAGE_INFO_2_KHR: Self = Self::BLIT_IMAGE_INFO_2;
+    pub const RESOLVE_IMAGE_INFO_2_KHR: Self = Self::RESOLVE_IMAGE_INFO_2;
+    pub const BUFFER_COPY_2_KHR: Self = Self::BUFFER_COPY_2;
+    pub const IMAGE_COPY_2_KHR: Self = Self::IMAGE_COPY_2;
+    pub const IMAGE_BLIT_2_KHR: Self = Self::IMAGE_BLIT_2;
+    pub const BUFFER_IMAGE_COPY_2_KHR: Self = Self::BUFFER_IMAGE_COPY_2;
+    pub const IMAGE_RESOLVE_2_KHR: Self = Self::IMAGE_RESOLVE_2;
+}
+impl ExtImageCompressionControlFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_compression_control\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn(
+    device: Device,
+    image: Image,
+    p_subresource: *const ImageSubresource2EXT,
+    p_layout: *mut SubresourceLayout2EXT,
+);
 #[derive(Clone)]
-pub struct ArmExtension339Fn {}
-unsafe impl Send for ArmExtension339Fn {}
-unsafe impl Sync for ArmExtension339Fn {}
-impl ArmExtension339Fn {
+pub struct ExtImageCompressionControlFn {
+    pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2EXT,
+}
+unsafe impl Send for ExtImageCompressionControlFn {}
+unsafe impl Sync for ExtImageCompressionControlFn {}
+impl ExtImageCompressionControlFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ArmExtension339Fn {}
+        Self {
+            get_image_subresource_layout2_ext: unsafe {
+                unsafe extern "system" fn get_image_subresource_layout2_ext(
+                    _device: Device,
+                    _image: Image,
+                    _p_subresource: *const ImageSubresource2EXT,
+                    _p_layout: *mut SubresourceLayout2EXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_image_subresource_layout2_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetImageSubresourceLayout2EXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_image_subresource_layout2_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
-impl ExtExtension340Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_340\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_EXT_image_compression_control'"]
+impl Result {
+    pub const ERROR_COMPRESSION_EXHAUSTED_EXT: Self = Self(-1_000_338_000);
+}
+#[doc = "Generated from 'VK_EXT_image_compression_control'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: Self = Self(1_000_338_000);
+    pub const IMAGE_COMPRESSION_CONTROL_EXT: Self = Self(1_000_338_001);
+    pub const SUBRESOURCE_LAYOUT_2_EXT: Self = Self(1_000_338_002);
+    pub const IMAGE_SUBRESOURCE_2_EXT: Self = Self(1_000_338_003);
+    pub const IMAGE_COMPRESSION_PROPERTIES_EXT: Self = Self(1_000_338_004);
+}
+impl ExtAttachmentFeedbackLoopLayoutFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_attachment_feedback_loop_layout\0",
+            )
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
 #[derive(Clone)]
-pub struct ExtExtension340Fn {}
-unsafe impl Send for ExtExtension340Fn {}
-unsafe impl Sync for ExtExtension340Fn {}
-impl ExtExtension340Fn {
+pub struct ExtAttachmentFeedbackLoopLayoutFn {}
+unsafe impl Send for ExtAttachmentFeedbackLoopLayoutFn {}
+unsafe impl Sync for ExtAttachmentFeedbackLoopLayoutFn {}
+impl ExtAttachmentFeedbackLoopLayoutFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension340Fn {}
+        Self {}
     }
 }
-#[doc = "Generated from 'VK_EXT_extension_340'"]
+#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
+impl DependencyFlags {
+    #[doc = "Dependency may be a feedback loop"]
+    pub const FEEDBACK_LOOP_EXT: Self = Self(0b1000);
+}
+#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
+impl ImageLayout {
+    pub const ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: Self = Self(1_000_339_000);
+}
+#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
 impl ImageUsageFlags {
-    pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000);
+    pub const ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b1000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
+impl PipelineCreateFlags {
+    pub const COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
+    pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: Self =
+        Self(1_000_339_000);
 }
 impl Ext4444FormatsFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_4444_formats\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_4444_formats\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -23028,63 +18907,125 @@ impl Ext4444FormatsFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        Ext4444FormatsFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_4444_formats'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: Self = Self(1_000_340_000);
-}
-#[doc = "Generated from 'VK_EXT_4444_formats'"]
 impl Format {
-    pub const A4R4G4B4_UNORM_PACK16_EXT: Self = Self(1_000_340_000);
+    pub const A4R4G4B4_UNORM_PACK16_EXT: Self = Self::A4R4G4B4_UNORM_PACK16;
+    pub const A4B4G4R4_UNORM_PACK16_EXT: Self = Self::A4B4G4R4_UNORM_PACK16;
 }
 #[doc = "Generated from 'VK_EXT_4444_formats'"]
-impl Format {
-    pub const A4B4G4R4_UNORM_PACK16_EXT: Self = Self(1_000_340_001);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: Self = Self(1_000_340_000);
 }
-impl ExtExtension342Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_342\0")
-            .expect("Wrong extension string")
+impl ExtDeviceFaultFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_fault\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn(
+    device: Device,
+    p_fault_counts: *mut DeviceFaultCountsEXT,
+    p_fault_info: *mut DeviceFaultInfoEXT,
+) -> Result;
 #[derive(Clone)]
-pub struct ExtExtension342Fn {}
-unsafe impl Send for ExtExtension342Fn {}
-unsafe impl Sync for ExtExtension342Fn {}
-impl ExtExtension342Fn {
+pub struct ExtDeviceFaultFn {
+    pub get_device_fault_info_ext: PFN_vkGetDeviceFaultInfoEXT,
+}
+unsafe impl Send for ExtDeviceFaultFn {}
+unsafe impl Sync for ExtDeviceFaultFn {}
+impl ExtDeviceFaultFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension342Fn {}
+        Self {
+            get_device_fault_info_ext: unsafe {
+                unsafe extern "system" fn get_device_fault_info_ext(
+                    _device: Device,
+                    _p_fault_counts: *mut DeviceFaultCountsEXT,
+                    _p_fault_info: *mut DeviceFaultInfoEXT,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_fault_info_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceFaultInfoEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_fault_info_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
-impl ArmExtension343Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_343\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_EXT_device_fault'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_FAULT_FEATURES_EXT: Self = Self(1_000_341_000);
+    pub const DEVICE_FAULT_COUNTS_EXT: Self = Self(1_000_341_001);
+    pub const DEVICE_FAULT_INFO_EXT: Self = Self(1_000_341_002);
+}
+impl ArmRasterizationOrderAttachmentAccessFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_ARM_rasterization_order_attachment_access\0",
+            )
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ArmExtension343Fn {}
-unsafe impl Send for ArmExtension343Fn {}
-unsafe impl Sync for ArmExtension343Fn {}
-impl ArmExtension343Fn {
+pub struct ArmRasterizationOrderAttachmentAccessFn {}
+unsafe impl Send for ArmRasterizationOrderAttachmentAccessFn {}
+unsafe impl Sync for ArmRasterizationOrderAttachmentAccessFn {}
+impl ArmRasterizationOrderAttachmentAccessFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ArmExtension343Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
+impl PipelineColorBlendStateCreateFlags {
+    pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM: Self =
+        Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT;
+}
+#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
+impl PipelineDepthStencilStateCreateFlags {
+    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self =
+        Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT;
+    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self =
+        Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT;
+}
+#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: Self =
+        Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
+}
+#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
+impl SubpassDescriptionFlags {
+    pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM: Self =
+        Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT;
+    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self =
+        Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT;
+    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self =
+        Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT;
+}
 impl ArmExtension344Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_344\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_344\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23097,32 +19038,36 @@ impl ArmExtension344Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ArmExtension344Fn {}
+        Self {}
     }
 }
-impl ArmExtension345Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_345\0")
-            .expect("Wrong extension string")
+impl ExtRgba10x6FormatsFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_rgba10x6_formats\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ArmExtension345Fn {}
-unsafe impl Send for ArmExtension345Fn {}
-unsafe impl Sync for ArmExtension345Fn {}
-impl ArmExtension345Fn {
+pub struct ExtRgba10x6FormatsFn {}
+unsafe impl Send for ExtRgba10x6FormatsFn {}
+unsafe impl Sync for ExtRgba10x6FormatsFn {}
+impl ExtRgba10x6FormatsFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ArmExtension345Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_EXT_rgba10x6_formats'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: Self = Self(1_000_344_000);
+}
 impl NvAcquireWinrtDisplayFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_acquire_winrt_display\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_acquire_winrt_display\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -23147,7 +19092,7 @@ impl NvAcquireWinrtDisplayFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvAcquireWinrtDisplayFn {
+        Self {
             acquire_winrt_display_nv: unsafe {
                 unsafe extern "system" fn acquire_winrt_display_nv(
                     _physical_device: PhysicalDevice,
@@ -23186,28 +19131,11 @@ impl NvAcquireWinrtDisplayFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAcquireWinrtDisplayNV.html>"]
-    pub unsafe fn acquire_winrt_display_nv(
-        &self,
-        physical_device: PhysicalDevice,
-        display: DisplayKHR,
-    ) -> Result {
-        (self.acquire_winrt_display_nv)(physical_device, display)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetWinrtDisplayNV.html>"]
-    pub unsafe fn get_winrt_display_nv(
-        &self,
-        physical_device: PhysicalDevice,
-        device_relative_id: u32,
-        p_display: *mut DisplayKHR,
-    ) -> Result {
-        (self.get_winrt_display_nv)(physical_device, device_relative_id, p_display)
-    }
 }
 impl ExtDirectfbSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_directfb_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_directfb_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -23238,7 +19166,7 @@ impl ExtDirectfbSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDirectfbSurfaceFn {
+        Self {
             create_direct_fb_surface_ext: unsafe {
                 unsafe extern "system" fn create_direct_fb_surface_ext(
                     _instance: Instance,
@@ -23284,38 +19212,15 @@ impl ExtDirectfbSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDirectFBSurfaceEXT.html>"]
-    pub unsafe fn create_direct_fb_surface_ext(
-        &self,
-        instance: Instance,
-        p_create_info: *const DirectFBSurfaceCreateInfoEXT,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_direct_fb_surface_ext)(instance, p_create_info, p_allocator, p_surface)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html>"]
-    pub unsafe fn get_physical_device_direct_fb_presentation_support_ext(
-        &self,
-        physical_device: PhysicalDevice,
-        queue_family_index: u32,
-        dfb: *mut IDirectFB,
-    ) -> Bool32 {
-        (self.get_physical_device_direct_fb_presentation_support_ext)(
-            physical_device,
-            queue_family_index,
-            dfb,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_directfb_surface'"]
 impl StructureType {
     pub const DIRECTFB_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_346_000);
 }
 impl KhrExtension350Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_350\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_350\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23328,13 +19233,13 @@ impl KhrExtension350Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension350Fn {}
+        Self {}
     }
 }
 impl NvExtension351Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_351\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_351\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23347,13 +19252,15 @@ impl NvExtension351Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension351Fn {}
+        Self {}
     }
 }
 impl ValveMutableDescriptorTypeFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_VALVE_mutable_descriptor_type\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_VALVE_mutable_descriptor_type\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -23366,33 +19273,34 @@ impl ValveMutableDescriptorTypeFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ValveMutableDescriptorTypeFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: Self = Self(1_000_351_000);
+impl DescriptorPoolCreateFlags {
+    pub const HOST_ONLY_VALVE: Self = Self::HOST_ONLY_EXT;
 }
 #[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
-impl StructureType {
-    pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: Self = Self(1_000_351_002);
+impl DescriptorSetLayoutCreateFlags {
+    pub const HOST_ONLY_POOL_VALVE: Self = Self::HOST_ONLY_POOL_EXT;
 }
 #[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
 impl DescriptorType {
-    pub const MUTABLE_VALVE: Self = Self(1_000_351_000);
+    pub const MUTABLE_VALVE: Self = Self::MUTABLE_EXT;
 }
 #[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
-impl DescriptorPoolCreateFlags {
-    pub const HOST_ONLY_VALVE: Self = Self(0b100);
-}
-#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
-impl DescriptorSetLayoutCreateFlags {
-    pub const HOST_ONLY_POOL_VALVE: Self = Self(0b100);
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: Self =
+        Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
+    pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: Self =
+        Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
 }
 impl ExtVertexInputDynamicStateFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_vertex_input_dynamic_state\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_input_dynamic_state\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -23415,7 +19323,7 @@ impl ExtVertexInputDynamicStateFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtVertexInputDynamicStateFn {
+        Self {
             cmd_set_vertex_input_ext: unsafe {
                 unsafe extern "system" fn cmd_set_vertex_input_ext(
                     _command_buffer: CommandBuffer,
@@ -23440,44 +19348,21 @@ impl ExtVertexInputDynamicStateFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetVertexInputEXT.html>"]
-    pub unsafe fn cmd_set_vertex_input_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        vertex_binding_description_count: u32,
-        p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT,
-        vertex_attribute_description_count: u32,
-        p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT,
-    ) {
-        (self.cmd_set_vertex_input_ext)(
-            command_buffer,
-            vertex_binding_description_count,
-            p_vertex_binding_descriptions,
-            vertex_attribute_description_count,
-            p_vertex_attribute_descriptions,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_352_000);
+impl DynamicState {
+    pub const VERTEX_INPUT_EXT: Self = Self(1_000_352_000);
 }
 #[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_352_000);
     pub const VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: Self = Self(1_000_352_001);
-}
-#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"]
-impl StructureType {
     pub const VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: Self = Self(1_000_352_002);
 }
-#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"]
-impl DynamicState {
-    pub const VERTEX_INPUT_EXT: Self = Self(1_000_352_000);
-}
 impl ExtPhysicalDeviceDrmFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_physical_device_drm\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_physical_device_drm\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -23490,55 +19375,77 @@ impl ExtPhysicalDeviceDrmFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtPhysicalDeviceDrmFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_physical_device_drm'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: Self = Self(1_000_353_000);
 }
-impl ExtExtension355Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_355\0")
-            .expect("Wrong extension string")
+impl ExtDeviceAddressBindingReportFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_device_address_binding_report\0",
+            )
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ExtExtension355Fn {}
-unsafe impl Send for ExtExtension355Fn {}
-unsafe impl Sync for ExtExtension355Fn {}
-impl ExtExtension355Fn {
+pub struct ExtDeviceAddressBindingReportFn {}
+unsafe impl Send for ExtDeviceAddressBindingReportFn {}
+unsafe impl Sync for ExtDeviceAddressBindingReportFn {}
+impl ExtDeviceAddressBindingReportFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension355Fn {}
+        Self {}
     }
 }
-impl ExtVertexAttributeAliasingFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_vertex_attribute_aliasing\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_EXT_device_address_binding_report'"]
+impl DebugUtilsMessageTypeFlagsEXT {
+    pub const DEVICE_ADDRESS_BINDING: Self = Self(0b1000);
+}
+#[doc = "Generated from 'VK_EXT_device_address_binding_report'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: Self = Self(1_000_354_000);
+    pub const DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: Self = Self(1_000_354_001);
+}
+impl ExtDepthClipControlFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_control\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ExtVertexAttributeAliasingFn {}
-unsafe impl Send for ExtVertexAttributeAliasingFn {}
-unsafe impl Sync for ExtVertexAttributeAliasingFn {}
-impl ExtVertexAttributeAliasingFn {
+pub struct ExtDepthClipControlFn {}
+unsafe impl Send for ExtDepthClipControlFn {}
+unsafe impl Sync for ExtDepthClipControlFn {}
+impl ExtDepthClipControlFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtVertexAttributeAliasingFn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_EXT_depth_clip_control'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: Self = Self(1_000_355_000);
+    pub const PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: Self = Self(1_000_355_001);
+}
 impl ExtPrimitiveTopologyListRestartFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_primitive_topology_list_restart\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_primitive_topology_list_restart\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -23551,7 +19458,7 @@ impl ExtPrimitiveTopologyListRestartFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtPrimitiveTopologyListRestartFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_primitive_topology_list_restart'"]
@@ -23560,9 +19467,9 @@ impl StructureType {
         Self(1_000_356_000);
 }
 impl KhrExtension358Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_358\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_358\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23575,13 +19482,13 @@ impl KhrExtension358Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension358Fn {}
+        Self {}
     }
 }
 impl ExtExtension359Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_359\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_359\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23594,13 +19501,13 @@ impl ExtExtension359Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension359Fn {}
+        Self {}
     }
 }
 impl ExtExtension360Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_360\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_360\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23613,32 +19520,38 @@ impl ExtExtension360Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension360Fn {}
+        Self {}
     }
 }
-impl KhrExtension361Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_361\0")
-            .expect("Wrong extension string")
+impl KhrFormatFeatureFlags2Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_format_feature_flags2\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
 #[derive(Clone)]
-pub struct KhrExtension361Fn {}
-unsafe impl Send for KhrExtension361Fn {}
-unsafe impl Sync for KhrExtension361Fn {}
-impl KhrExtension361Fn {
+pub struct KhrFormatFeatureFlags2Fn {}
+unsafe impl Send for KhrFormatFeatureFlags2Fn {}
+unsafe impl Sync for KhrFormatFeatureFlags2Fn {}
+impl KhrFormatFeatureFlags2Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension361Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_KHR_format_feature_flags2'"]
+impl StructureType {
+    pub const FORMAT_PROPERTIES_3_KHR: Self = Self::FORMAT_PROPERTIES_3;
+}
 impl ExtExtension362Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_362\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_362\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23651,13 +19564,13 @@ impl ExtExtension362Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension362Fn {}
+        Self {}
     }
 }
 impl ExtExtension363Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_363\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_363\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23670,13 +19583,13 @@ impl ExtExtension363Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension363Fn {}
+        Self {}
     }
 }
 impl FuchsiaExtension364Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_extension_364\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_364\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23689,13 +19602,13 @@ impl FuchsiaExtension364Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        FuchsiaExtension364Fn {}
+        Self {}
     }
 }
 impl FuchsiaExternalMemoryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_external_memory\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_memory\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -23724,7 +19637,7 @@ impl FuchsiaExternalMemoryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        FuchsiaExternalMemoryFn {
+        Self {
             get_memory_zircon_handle_fuchsia: unsafe {
                 unsafe extern "system" fn get_memory_zircon_handle_fuchsia(
                     _device: Device,
@@ -23770,51 +19683,23 @@ impl FuchsiaExternalMemoryFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryZirconHandleFUCHSIA.html>"]
-    pub unsafe fn get_memory_zircon_handle_fuchsia(
-        &self,
-        device: Device,
-        p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA,
-        p_zircon_handle: *mut zx_handle_t,
-    ) -> Result {
-        (self.get_memory_zircon_handle_fuchsia)(device, p_get_zircon_handle_info, p_zircon_handle)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html>"]
-    pub unsafe fn get_memory_zircon_handle_properties_fuchsia(
-        &self,
-        device: Device,
-        handle_type: ExternalMemoryHandleTypeFlags,
-        zircon_handle: zx_handle_t,
-        p_memory_zircon_handle_properties: *mut MemoryZirconHandlePropertiesFUCHSIA,
-    ) -> Result {
-        (self.get_memory_zircon_handle_properties_fuchsia)(
-            device,
-            handle_type,
-            zircon_handle,
-            p_memory_zircon_handle_properties,
-        )
-    }
 }
 #[doc = "Generated from 'VK_FUCHSIA_external_memory'"]
-impl StructureType {
-    pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_000);
+impl ExternalMemoryHandleTypeFlags {
+    pub const ZIRCON_VMO_FUCHSIA: Self = Self(0b1000_0000_0000);
 }
 #[doc = "Generated from 'VK_FUCHSIA_external_memory'"]
 impl StructureType {
+    pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_000);
     pub const MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: Self = Self(1_000_364_001);
-}
-#[doc = "Generated from 'VK_FUCHSIA_external_memory'"]
-impl StructureType {
     pub const MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_002);
 }
-#[doc = "Generated from 'VK_FUCHSIA_external_memory'"]
-impl ExternalMemoryHandleTypeFlags {
-    pub const ZIRCON_VMO_FUCHSIA: Self = Self(0b1000_0000_0000);
-}
 impl FuchsiaExternalSemaphoreFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_external_semaphore\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_semaphore\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -23841,7 +19726,7 @@ impl FuchsiaExternalSemaphoreFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        FuchsiaExternalSemaphoreFn {
+        Self {
             import_semaphore_zircon_handle_fuchsia: unsafe {
                 unsafe extern "system" fn import_semaphore_zircon_handle_fuchsia(
                     _device: Device,
@@ -23885,63 +19770,209 @@ impl FuchsiaExternalSemaphoreFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html>"]
-    pub unsafe fn import_semaphore_zircon_handle_fuchsia(
-        &self,
-        device: Device,
-        p_import_semaphore_zircon_handle_info: *const ImportSemaphoreZirconHandleInfoFUCHSIA,
-    ) -> Result {
-        (self.import_semaphore_zircon_handle_fuchsia)(device, p_import_semaphore_zircon_handle_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html>"]
-    pub unsafe fn get_semaphore_zircon_handle_fuchsia(
-        &self,
-        device: Device,
-        p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA,
-        p_zircon_handle: *mut zx_handle_t,
-    ) -> Result {
-        (self.get_semaphore_zircon_handle_fuchsia)(
-            device,
-            p_get_zircon_handle_info,
-            p_zircon_handle,
-        )
-    }
 }
 #[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"]
-impl StructureType {
-    pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_000);
+impl ExternalSemaphoreHandleTypeFlags {
+    pub const ZIRCON_EVENT_FUCHSIA: Self = Self(0b1000_0000);
 }
 #[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"]
 impl StructureType {
+    pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_000);
     pub const SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_001);
 }
-#[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"]
-impl ExternalSemaphoreHandleTypeFlags {
-    pub const ZIRCON_EVENT_FUCHSIA: Self = Self(0b1000_0000);
-}
-impl FuchsiaExtension367Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_extension_367\0")
-            .expect("Wrong extension string")
+impl FuchsiaBufferCollectionFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_buffer_collection\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateBufferCollectionFUCHSIA = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const BufferCollectionCreateInfoFUCHSIA,
+    p_allocator: *const AllocationCallbacks,
+    p_collection: *mut BufferCollectionFUCHSIA,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = unsafe extern "system" fn(
+    device: Device,
+    collection: BufferCollectionFUCHSIA,
+    p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = unsafe extern "system" fn(
+    device: Device,
+    collection: BufferCollectionFUCHSIA,
+    p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyBufferCollectionFUCHSIA = unsafe extern "system" fn(
+    device: Device,
+    collection: BufferCollectionFUCHSIA,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetBufferCollectionPropertiesFUCHSIA = unsafe extern "system" fn(
+    device: Device,
+    collection: BufferCollectionFUCHSIA,
+    p_properties: *mut BufferCollectionPropertiesFUCHSIA,
+) -> Result;
 #[derive(Clone)]
-pub struct FuchsiaExtension367Fn {}
-unsafe impl Send for FuchsiaExtension367Fn {}
-unsafe impl Sync for FuchsiaExtension367Fn {}
-impl FuchsiaExtension367Fn {
+pub struct FuchsiaBufferCollectionFn {
+    pub create_buffer_collection_fuchsia: PFN_vkCreateBufferCollectionFUCHSIA,
+    pub set_buffer_collection_image_constraints_fuchsia:
+        PFN_vkSetBufferCollectionImageConstraintsFUCHSIA,
+    pub set_buffer_collection_buffer_constraints_fuchsia:
+        PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA,
+    pub destroy_buffer_collection_fuchsia: PFN_vkDestroyBufferCollectionFUCHSIA,
+    pub get_buffer_collection_properties_fuchsia: PFN_vkGetBufferCollectionPropertiesFUCHSIA,
+}
+unsafe impl Send for FuchsiaBufferCollectionFn {}
+unsafe impl Sync for FuchsiaBufferCollectionFn {}
+impl FuchsiaBufferCollectionFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        FuchsiaExtension367Fn {}
+        Self {
+            create_buffer_collection_fuchsia: unsafe {
+                unsafe extern "system" fn create_buffer_collection_fuchsia(
+                    _device: Device,
+                    _p_create_info: *const BufferCollectionCreateInfoFUCHSIA,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_collection: *mut BufferCollectionFUCHSIA,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_buffer_collection_fuchsia)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCreateBufferCollectionFUCHSIA\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    create_buffer_collection_fuchsia
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            set_buffer_collection_image_constraints_fuchsia: unsafe {
+                unsafe extern "system" fn set_buffer_collection_image_constraints_fuchsia(
+                    _device: Device,
+                    _collection: BufferCollectionFUCHSIA,
+                    _p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(set_buffer_collection_image_constraints_fuchsia)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkSetBufferCollectionImageConstraintsFUCHSIA\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    set_buffer_collection_image_constraints_fuchsia
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            set_buffer_collection_buffer_constraints_fuchsia: unsafe {
+                unsafe extern "system" fn set_buffer_collection_buffer_constraints_fuchsia(
+                    _device: Device,
+                    _collection: BufferCollectionFUCHSIA,
+                    _p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(set_buffer_collection_buffer_constraints_fuchsia)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkSetBufferCollectionBufferConstraintsFUCHSIA\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    set_buffer_collection_buffer_constraints_fuchsia
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_buffer_collection_fuchsia: unsafe {
+                unsafe extern "system" fn destroy_buffer_collection_fuchsia(
+                    _device: Device,
+                    _collection: BufferCollectionFUCHSIA,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_buffer_collection_fuchsia)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkDestroyBufferCollectionFUCHSIA\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_buffer_collection_fuchsia
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_buffer_collection_properties_fuchsia: unsafe {
+                unsafe extern "system" fn get_buffer_collection_properties_fuchsia(
+                    _device: Device,
+                    _collection: BufferCollectionFUCHSIA,
+                    _p_properties: *mut BufferCollectionPropertiesFUCHSIA,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_buffer_collection_properties_fuchsia)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetBufferCollectionPropertiesFUCHSIA\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_buffer_collection_properties_fuchsia
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
+#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"]
+impl DebugReportObjectTypeEXT {
+    pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000);
+}
+#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"]
+impl ObjectType {
+    #[doc = "VkBufferCollectionFUCHSIA"]
+    pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000);
+}
+#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"]
+impl StructureType {
+    pub const BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_000);
+    pub const IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_001);
+    pub const BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_002);
+    pub const BUFFER_COLLECTION_PROPERTIES_FUCHSIA: Self = Self(1_000_366_003);
+    pub const BUFFER_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_004);
+    pub const BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_005);
+    pub const IMAGE_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_006);
+    pub const IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_007);
+    pub const SYSMEM_COLOR_SPACE_FUCHSIA: Self = Self(1_000_366_008);
+    pub const BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_009);
+}
 impl FuchsiaExtension368Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_FUCHSIA_extension_368\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_368\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23954,13 +19985,13 @@ impl FuchsiaExtension368Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        FuchsiaExtension368Fn {}
+        Self {}
     }
 }
 impl QcomExtension369Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QCOM_extension_369\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_369\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -23973,7 +20004,7 @@ impl QcomExtension369Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QcomExtension369Fn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_QCOM_extension_369'"]
@@ -23981,9 +20012,9 @@ impl DescriptorBindingFlags {
     pub const RESERVED_4_QCOM: Self = Self(0b1_0000);
 }
 impl HuaweiSubpassShadingFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_subpass_shading\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_subpass_shading\0") }
     }
     pub const SPEC_VERSION: u32 = 2u32;
 }
@@ -24008,7 +20039,7 @@ impl HuaweiSubpassShadingFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        HuaweiSubpassShadingFn {
+        Self {
             get_device_subpass_shading_max_workgroup_size_huawei: unsafe {
                 unsafe extern "system" fn get_device_subpass_shading_max_workgroup_size_huawei(
                     _device: Device,
@@ -24050,42 +20081,13 @@ impl HuaweiSubpassShadingFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html>"]
-    pub unsafe fn get_device_subpass_shading_max_workgroup_size_huawei(
-        &self,
-        device: Device,
-        renderpass: RenderPass,
-        p_max_workgroup_size: *mut Extent2D,
-    ) -> Result {
-        (self.get_device_subpass_shading_max_workgroup_size_huawei)(
-            device,
-            renderpass,
-            p_max_workgroup_size,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSubpassShadingHUAWEI.html>"]
-    pub unsafe fn cmd_subpass_shading_huawei(&self, command_buffer: CommandBuffer) {
-        (self.cmd_subpass_shading_huawei)(command_buffer)
-    }
-}
-#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
-impl StructureType {
-    pub const SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: Self = Self(1_000_369_000);
-}
-#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: Self = Self(1_000_369_001);
-}
-#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: Self = Self(1_000_369_002);
 }
 #[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
 impl PipelineBindPoint {
     pub const SUBPASS_SHADING_HUAWEI: Self = Self(1_000_369_003);
 }
 #[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
-impl PipelineStageFlags2KHR {
+impl PipelineStageFlags2 {
     pub const SUBPASS_SHADING_HUAWEI: Self =
         Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
 }
@@ -24093,10 +20095,16 @@ impl PipelineStageFlags2KHR {
 impl ShaderStageFlags {
     pub const SUBPASS_SHADING_HUAWEI: Self = Self(0b100_0000_0000_0000);
 }
+#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
+impl StructureType {
+    pub const SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: Self = Self(1_000_369_000);
+    pub const PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: Self = Self(1_000_369_001);
+    pub const PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: Self = Self(1_000_369_002);
+}
 impl HuaweiInvocationMaskFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_invocation_mask\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_invocation_mask\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -24117,7 +20125,7 @@ impl HuaweiInvocationMaskFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        HuaweiInvocationMaskFn {
+        Self {
             cmd_bind_invocation_mask_huawei: unsafe {
                 unsafe extern "system" fn cmd_bind_invocation_mask_huawei(
                     _command_buffer: CommandBuffer,
@@ -24141,22 +20149,9 @@ impl HuaweiInvocationMaskFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindInvocationMaskHUAWEI.html>"]
-    pub unsafe fn cmd_bind_invocation_mask_huawei(
-        &self,
-        command_buffer: CommandBuffer,
-        image_view: ImageView,
-        image_layout: ImageLayout,
-    ) {
-        (self.cmd_bind_invocation_mask_huawei)(command_buffer, image_view, image_layout)
-    }
-}
-#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1_000_370_000);
 }
 #[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
-impl AccessFlags2KHR {
+impl AccessFlags2 {
     pub const INVOCATION_MASK_READ_HUAWEI: Self =
         Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
 }
@@ -24165,14 +20160,18 @@ impl ImageUsageFlags {
     pub const INVOCATION_MASK_HUAWEI: Self = Self(0b100_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
-impl PipelineStageFlags2KHR {
+impl PipelineStageFlags2 {
     pub const INVOCATION_MASK_HUAWEI: Self =
         Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
 }
+#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1_000_370_000);
+}
 impl NvExternalMemoryRdmaFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_external_memory_rdma\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_rdma\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -24193,7 +20192,7 @@ impl NvExternalMemoryRdmaFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExternalMemoryRdmaFn {
+        Self {
             get_memory_remote_address_nv: unsafe {
                 unsafe extern "system" fn get_memory_remote_address_nv(
                     _device: Device,
@@ -24217,113 +20216,83 @@ impl NvExternalMemoryRdmaFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetMemoryRemoteAddressNV.html>"]
-    pub unsafe fn get_memory_remote_address_nv(
-        &self,
-        device: Device,
-        p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
-        p_address: *mut RemoteAddressNV,
-    ) -> Result {
-        (self.get_memory_remote_address_nv)(device, p_memory_get_remote_address_info, p_address)
-    }
-}
-#[doc = "Generated from 'VK_NV_external_memory_rdma'"]
-impl StructureType {
-    pub const MEMORY_GET_REMOTE_ADDRESS_INFO_NV: Self = Self(1_000_371_000);
 }
 #[doc = "Generated from 'VK_NV_external_memory_rdma'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: Self = Self(1_000_371_001);
+impl ExternalMemoryHandleTypeFlags {
+    pub const RDMA_ADDRESS_NV: Self = Self(0b1_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_NV_external_memory_rdma'"]
 impl MemoryPropertyFlags {
     pub const RDMA_CAPABLE_NV: Self = Self(0b1_0000_0000);
 }
 #[doc = "Generated from 'VK_NV_external_memory_rdma'"]
-impl ExternalMemoryHandleTypeFlags {
-    pub const RDMA_ADDRESS_NV: Self = Self(0b1_0000_0000_0000);
-}
-impl NvExtension373Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_373\0")
-            .expect("Wrong extension string")
-    }
-    pub const SPEC_VERSION: u32 = 0u32;
-}
-#[derive(Clone)]
-pub struct NvExtension373Fn {}
-unsafe impl Send for NvExtension373Fn {}
-unsafe impl Sync for NvExtension373Fn {}
-impl NvExtension373Fn {
-    pub fn load<F>(mut _f: F) -> Self
-    where
-        F: FnMut(&::std::ffi::CStr) -> *const c_void,
-    {
-        NvExtension373Fn {}
-    }
+impl StructureType {
+    pub const MEMORY_GET_REMOTE_ADDRESS_INFO_NV: Self = Self(1_000_371_000);
+    pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: Self = Self(1_000_371_001);
 }
-impl NvExtension374Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_374\0")
-            .expect("Wrong extension string")
+impl ExtPipelinePropertiesFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_properties\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+#[doc = "Implemented for all types that can be passed as argument to `pipeline_properties` in [`PFN_vkGetPipelinePropertiesEXT`]"]
+pub unsafe trait GetPipelinePropertiesEXTParamPipelineProperties {}
+unsafe impl GetPipelinePropertiesEXTParamPipelineProperties for PipelinePropertiesIdentifierEXT {}
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPipelinePropertiesEXT = unsafe extern "system" fn(
+    device: Device,
+    p_pipeline_info: *const PipelineInfoEXT,
+    p_pipeline_properties: *mut BaseOutStructure,
+) -> Result;
 #[derive(Clone)]
-pub struct NvExtension374Fn {}
-unsafe impl Send for NvExtension374Fn {}
-unsafe impl Sync for NvExtension374Fn {}
-impl NvExtension374Fn {
-    pub fn load<F>(mut _f: F) -> Self
-    where
-        F: FnMut(&::std::ffi::CStr) -> *const c_void,
-    {
-        NvExtension374Fn {}
-    }
+pub struct ExtPipelinePropertiesFn {
+    pub get_pipeline_properties_ext: PFN_vkGetPipelinePropertiesEXT,
 }
-#[doc = "Generated from 'VK_NV_extension_374'"]
-impl ExternalFenceHandleTypeFlags {
-    pub const RESERVED_4_NV: Self = Self(0b1_0000);
-}
-#[doc = "Generated from 'VK_NV_extension_374'"]
-impl ExternalFenceHandleTypeFlags {
-    pub const RESERVED_5_NV: Self = Self(0b10_0000);
-}
-#[doc = "Generated from 'VK_NV_extension_374'"]
-impl ExternalSemaphoreHandleTypeFlags {
-    pub const RESERVED_5_NV: Self = Self(0b10_0000);
-}
-#[doc = "Generated from 'VK_NV_extension_374'"]
-impl ExternalSemaphoreHandleTypeFlags {
-    pub const RESERVED_6_NV: Self = Self(0b100_0000);
-}
-impl NvExtension375Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_375\0")
-            .expect("Wrong extension string")
-    }
-    pub const SPEC_VERSION: u32 = 0u32;
-}
-#[derive(Clone)]
-pub struct NvExtension375Fn {}
-unsafe impl Send for NvExtension375Fn {}
-unsafe impl Sync for NvExtension375Fn {}
-impl NvExtension375Fn {
+unsafe impl Send for ExtPipelinePropertiesFn {}
+unsafe impl Sync for ExtPipelinePropertiesFn {}
+impl ExtPipelinePropertiesFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension375Fn {}
+        Self {
+            get_pipeline_properties_ext: unsafe {
+                unsafe extern "system" fn get_pipeline_properties_ext(
+                    _device: Device,
+                    _p_pipeline_info: *const PipelineInfoEXT,
+                    _p_pipeline_properties: *mut BaseOutStructure,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_pipeline_properties_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPipelinePropertiesEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_pipeline_properties_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
-#[doc = "Generated from 'VK_NV_extension_375'"]
-impl ExternalMemoryHandleTypeFlags {
-    pub const RESERVED_13_NV: Self = Self(0b10_0000_0000_0000);
+#[doc = "Generated from 'VK_EXT_pipeline_properties'"]
+impl StructureType {
+    pub const PIPELINE_PROPERTIES_IDENTIFIER_EXT: Self = Self(1_000_372_000);
+    pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: Self = Self(1_000_372_001);
+    pub const PIPELINE_INFO_EXT: Self = Self::PIPELINE_INFO_KHR;
 }
 impl ExtExtension376Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_376\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_376\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -24336,32 +20305,49 @@ impl ExtExtension376Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension376Fn {}
+        Self {}
     }
 }
-impl ExtExtension377Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_377\0")
-            .expect("Wrong extension string")
+impl ExtMultisampledRenderToSingleSampledFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_multisampled_render_to_single_sampled\0",
+            )
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ExtExtension377Fn {}
-unsafe impl Send for ExtExtension377Fn {}
-unsafe impl Sync for ExtExtension377Fn {}
-impl ExtExtension377Fn {
+pub struct ExtMultisampledRenderToSingleSampledFn {}
+unsafe impl Send for ExtMultisampledRenderToSingleSampledFn {}
+unsafe impl Sync for ExtMultisampledRenderToSingleSampledFn {}
+impl ExtMultisampledRenderToSingleSampledFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension377Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"]
+impl ImageCreateFlags {
+    pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT: Self = Self(0b100_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: Self =
+        Self(1_000_376_000);
+    pub const SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: Self = Self(1_000_376_001);
+    pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: Self = Self(1_000_376_002);
+}
 impl ExtExtendedDynamicState2Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extended_dynamic_state2\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state2\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -24369,24 +20355,24 @@ impl ExtExtendedDynamicState2Fn {
 pub type PFN_vkCmdSetPatchControlPointsEXT =
     unsafe extern "system" fn(command_buffer: CommandBuffer, patch_control_points: u32);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetRasterizerDiscardEnableEXT =
+pub type PFN_vkCmdSetRasterizerDiscardEnable =
     unsafe extern "system" fn(command_buffer: CommandBuffer, rasterizer_discard_enable: Bool32);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetDepthBiasEnableEXT =
+pub type PFN_vkCmdSetDepthBiasEnable =
     unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bias_enable: Bool32);
 #[allow(non_camel_case_types)]
 pub type PFN_vkCmdSetLogicOpEXT =
     unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op: LogicOp);
 #[allow(non_camel_case_types)]
-pub type PFN_vkCmdSetPrimitiveRestartEnableEXT =
+pub type PFN_vkCmdSetPrimitiveRestartEnable =
     unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_restart_enable: Bool32);
 #[derive(Clone)]
 pub struct ExtExtendedDynamicState2Fn {
     pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT,
-    pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnableEXT,
-    pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnableEXT,
+    pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnable,
+    pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnable,
     pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT,
-    pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnableEXT,
+    pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnable,
 }
 unsafe impl Send for ExtExtendedDynamicState2Fn {}
 unsafe impl Sync for ExtExtendedDynamicState2Fn {}
@@ -24395,7 +20381,7 @@ impl ExtExtendedDynamicState2Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtendedDynamicState2Fn {
+        Self {
             cmd_set_patch_control_points_ext: unsafe {
                 unsafe extern "system" fn cmd_set_patch_control_points_ext(
                     _command_buffer: CommandBuffer,
@@ -24494,71 +20480,26 @@ impl ExtExtendedDynamicState2Fn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetPatchControlPointsEXT.html>"]
-    pub unsafe fn cmd_set_patch_control_points_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        patch_control_points: u32,
-    ) {
-        (self.cmd_set_patch_control_points_ext)(command_buffer, patch_control_points)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetRasterizerDiscardEnableEXT.html>"]
-    pub unsafe fn cmd_set_rasterizer_discard_enable_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        rasterizer_discard_enable: Bool32,
-    ) {
-        (self.cmd_set_rasterizer_discard_enable_ext)(command_buffer, rasterizer_discard_enable)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBiasEnableEXT.html>"]
-    pub unsafe fn cmd_set_depth_bias_enable_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        depth_bias_enable: Bool32,
-    ) {
-        (self.cmd_set_depth_bias_enable_ext)(command_buffer, depth_bias_enable)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetLogicOpEXT.html>"]
-    pub unsafe fn cmd_set_logic_op_ext(&self, command_buffer: CommandBuffer, logic_op: LogicOp) {
-        (self.cmd_set_logic_op_ext)(command_buffer, logic_op)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetPrimitiveRestartEnableEXT.html>"]
-    pub unsafe fn cmd_set_primitive_restart_enable_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        primitive_restart_enable: Bool32,
-    ) {
-        (self.cmd_set_primitive_restart_enable_ext)(command_buffer, primitive_restart_enable)
-    }
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: Self = Self(1_000_377_000);
 }
 #[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
 impl DynamicState {
+    #[doc = "Not promoted to 1.3"]
     pub const PATCH_CONTROL_POINTS_EXT: Self = Self(1_000_377_000);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
-impl DynamicState {
-    pub const RASTERIZER_DISCARD_ENABLE_EXT: Self = Self(1_000_377_001);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
-impl DynamicState {
-    pub const DEPTH_BIAS_ENABLE_EXT: Self = Self(1_000_377_002);
-}
-#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
-impl DynamicState {
+    pub const RASTERIZER_DISCARD_ENABLE_EXT: Self = Self::RASTERIZER_DISCARD_ENABLE;
+    pub const DEPTH_BIAS_ENABLE_EXT: Self = Self::DEPTH_BIAS_ENABLE;
+    #[doc = "Not promoted to 1.3"]
     pub const LOGIC_OP_EXT: Self = Self(1_000_377_003);
+    pub const PRIMITIVE_RESTART_ENABLE_EXT: Self = Self::PRIMITIVE_RESTART_ENABLE;
 }
 #[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
-impl DynamicState {
-    pub const PRIMITIVE_RESTART_ENABLE_EXT: Self = Self(1_000_377_004);
+impl StructureType {
+    #[doc = "Not promoted to 1.3"]
+    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: Self = Self(1_000_377_000);
 }
 impl QnxScreenSurfaceFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_QNX_screen_surface\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_screen_surface\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -24588,7 +20529,7 @@ impl QnxScreenSurfaceFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        QnxScreenSurfaceFn {
+        Self {
             create_screen_surface_qnx: unsafe {
                 unsafe extern "system" fn create_screen_surface_qnx(
                     _instance: Instance,
@@ -24633,38 +20574,15 @@ impl QnxScreenSurfaceFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateScreenSurfaceQNX.html>"]
-    pub unsafe fn create_screen_surface_qnx(
-        &self,
-        instance: Instance,
-        p_create_info: *const ScreenSurfaceCreateInfoQNX,
-        p_allocator: *const AllocationCallbacks,
-        p_surface: *mut SurfaceKHR,
-    ) -> Result {
-        (self.create_screen_surface_qnx)(instance, p_create_info, p_allocator, p_surface)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html>"]
-    pub unsafe fn get_physical_device_screen_presentation_support_qnx(
-        &self,
-        physical_device: PhysicalDevice,
-        queue_family_index: u32,
-        window: *mut _screen_window,
-    ) -> Bool32 {
-        (self.get_physical_device_screen_presentation_support_qnx)(
-            physical_device,
-            queue_family_index,
-            window,
-        )
-    }
 }
 #[doc = "Generated from 'VK_QNX_screen_surface'"]
 impl StructureType {
     pub const SCREEN_SURFACE_CREATE_INFO_QNX: Self = Self(1_000_378_000);
 }
 impl KhrExtension380Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_380\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_380\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -24677,13 +20595,13 @@ impl KhrExtension380Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension380Fn {}
+        Self {}
     }
 }
 impl KhrExtension381Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_381\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_381\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -24696,13 +20614,13 @@ impl KhrExtension381Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension381Fn {}
+        Self {}
     }
 }
 impl ExtColorWriteEnableFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_color_write_enable\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_color_write_enable\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -24723,7 +20641,7 @@ impl ExtColorWriteEnableFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtColorWriteEnableFn {
+        Self {
             cmd_set_color_write_enable_ext: unsafe {
                 unsafe extern "system" fn cmd_set_color_write_enable_ext(
                     _command_buffer: CommandBuffer,
@@ -24747,55 +20665,49 @@ impl ExtColorWriteEnableFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetColorWriteEnableEXT.html>"]
-    pub unsafe fn cmd_set_color_write_enable_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        attachment_count: u32,
-        p_color_write_enables: *const Bool32,
-    ) {
-        (self.cmd_set_color_write_enable_ext)(
-            command_buffer,
-            attachment_count,
-            p_color_write_enables,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_color_write_enable'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: Self = Self(1_000_381_000);
+impl DynamicState {
+    pub const COLOR_WRITE_ENABLE_EXT: Self = Self(1_000_381_000);
 }
 #[doc = "Generated from 'VK_EXT_color_write_enable'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: Self = Self(1_000_381_000);
     pub const PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: Self = Self(1_000_381_001);
 }
-#[doc = "Generated from 'VK_EXT_color_write_enable'"]
-impl DynamicState {
-    pub const COLOR_WRITE_ENABLE_EXT: Self = Self(1_000_381_000);
-}
-impl ExtExtension383Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_383\0")
-            .expect("Wrong extension string")
+impl ExtPrimitivesGeneratedQueryFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_primitives_generated_query\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ExtExtension383Fn {}
-unsafe impl Send for ExtExtension383Fn {}
-unsafe impl Sync for ExtExtension383Fn {}
-impl ExtExtension383Fn {
+pub struct ExtPrimitivesGeneratedQueryFn {}
+unsafe impl Send for ExtPrimitivesGeneratedQueryFn {}
+unsafe impl Sync for ExtPrimitivesGeneratedQueryFn {}
+impl ExtPrimitivesGeneratedQueryFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension383Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_EXT_primitives_generated_query'"]
+impl QueryType {
+    pub const PRIMITIVES_GENERATED_EXT: Self = Self(1_000_382_000);
+}
+#[doc = "Generated from 'VK_EXT_primitives_generated_query'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: Self = Self(1_000_382_000);
+}
 impl ExtExtension384Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_384\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_384\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -24808,13 +20720,13 @@ impl ExtExtension384Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension384Fn {}
+        Self {}
     }
 }
 impl MesaExtension385Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_MESA_extension_385\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_385\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -24827,13 +20739,13 @@ impl MesaExtension385Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        MesaExtension385Fn {}
+        Self {}
     }
 }
 impl GoogleExtension386Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GOOGLE_extension_386\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_386\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -24846,32 +20758,81 @@ impl GoogleExtension386Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GoogleExtension386Fn {}
+        Self {}
     }
 }
-impl KhrExtension387Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_387\0")
-            .expect("Wrong extension string")
+impl KhrRayTracingMaintenance1Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_maintenance1\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdTraceRaysIndirect2KHR = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    indirect_device_address: DeviceAddress,
+);
 #[derive(Clone)]
-pub struct KhrExtension387Fn {}
-unsafe impl Send for KhrExtension387Fn {}
-unsafe impl Sync for KhrExtension387Fn {}
-impl KhrExtension387Fn {
+pub struct KhrRayTracingMaintenance1Fn {
+    pub cmd_trace_rays_indirect2_khr: PFN_vkCmdTraceRaysIndirect2KHR,
+}
+unsafe impl Send for KhrRayTracingMaintenance1Fn {}
+unsafe impl Sync for KhrRayTracingMaintenance1Fn {}
+impl KhrRayTracingMaintenance1Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension387Fn {}
+        Self {
+            cmd_trace_rays_indirect2_khr: unsafe {
+                unsafe extern "system" fn cmd_trace_rays_indirect2_khr(
+                    _command_buffer: CommandBuffer,
+                    _indirect_device_address: DeviceAddress,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_trace_rays_indirect2_khr)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdTraceRaysIndirect2KHR\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_trace_rays_indirect2_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
+#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"]
+impl AccessFlags2 {
+    pub const SHADER_BINDING_TABLE_READ_KHR: Self =
+        Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"]
+impl PipelineStageFlags2 {
+    pub const ACCELERATION_STRUCTURE_COPY_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"]
+impl QueryType {
+    pub const ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: Self =
+        Self(1_000_386_000);
+    pub const ACCELERATION_STRUCTURE_SIZE_KHR: Self = Self(1_000_386_001);
+}
+#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: Self = Self(1_000_386_000);
+}
 impl ExtExtension388Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_388\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_388\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -24884,13 +20845,15 @@ impl ExtExtension388Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension388Fn {}
+        Self {}
     }
 }
 impl ExtGlobalPriorityQueryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_global_priority_query\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority_query\0")
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -24903,21 +20866,20 @@ impl ExtGlobalPriorityQueryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtGlobalPriorityQueryFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_global_priority_query'"]
 impl StructureType {
-    pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: Self = Self(1_000_388_000);
-}
-#[doc = "Generated from 'VK_EXT_global_priority_query'"]
-impl StructureType {
-    pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: Self = Self(1_000_388_001);
+    pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: Self =
+        Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
+    pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: Self =
+        Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
 }
 impl ExtExtension390Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_390\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_390\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -24930,13 +20892,13 @@ impl ExtExtension390Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension390Fn {}
+        Self {}
     }
 }
 impl ExtExtension391Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_391\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_391\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -24949,32 +20911,37 @@ impl ExtExtension391Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension391Fn {}
+        Self {}
     }
 }
-impl ExtExtension392Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_392\0")
-            .expect("Wrong extension string")
+impl ExtImageViewMinLodFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_view_min_lod\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ExtExtension392Fn {}
-unsafe impl Send for ExtExtension392Fn {}
-unsafe impl Sync for ExtExtension392Fn {}
-impl ExtExtension392Fn {
+pub struct ExtImageViewMinLodFn {}
+unsafe impl Send for ExtImageViewMinLodFn {}
+unsafe impl Sync for ExtImageViewMinLodFn {}
+impl ExtImageViewMinLodFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension392Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_EXT_image_view_min_lod'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: Self = Self(1_000_391_000);
+    pub const IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: Self = Self(1_000_391_001);
+}
 impl ExtMultiDrawFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_multi_draw\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_multi_draw\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -25009,7 +20976,7 @@ impl ExtMultiDrawFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtMultiDrawFn {
+        Self {
             cmd_draw_multi_ext: unsafe {
                 unsafe extern "system" fn cmd_draw_multi_ext(
                     _command_buffer: CommandBuffer,
@@ -25055,154 +21022,588 @@ impl ExtMultiDrawFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawMultiEXT.html>"]
-    pub unsafe fn cmd_draw_multi_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        draw_count: u32,
-        p_vertex_info: *const MultiDrawInfoEXT,
-        instance_count: u32,
-        first_instance: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_multi_ext)(
-            command_buffer,
-            draw_count,
-            p_vertex_info,
-            instance_count,
-            first_instance,
-            stride,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawMultiIndexedEXT.html>"]
-    pub unsafe fn cmd_draw_multi_indexed_ext(
-        &self,
-        command_buffer: CommandBuffer,
-        draw_count: u32,
-        p_index_info: *const MultiDrawIndexedInfoEXT,
-        instance_count: u32,
-        first_instance: u32,
-        stride: u32,
-        p_vertex_offset: *const i32,
-    ) {
-        (self.cmd_draw_multi_indexed_ext)(
-            command_buffer,
-            draw_count,
-            p_index_info,
-            instance_count,
-            first_instance,
-            stride,
-            p_vertex_offset,
-        )
-    }
 }
 #[doc = "Generated from 'VK_EXT_multi_draw'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: Self = Self(1_000_392_000);
-}
-#[doc = "Generated from 'VK_EXT_multi_draw'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: Self = Self(1_000_392_001);
 }
-impl ExtExtension394Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_394\0")
-            .expect("Wrong extension string")
+impl ExtImage2dViewOf3dFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_2d_view_of_3d\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ExtExtension394Fn {}
-unsafe impl Send for ExtExtension394Fn {}
-unsafe impl Sync for ExtExtension394Fn {}
-impl ExtExtension394Fn {
+pub struct ExtImage2dViewOf3dFn {}
+unsafe impl Send for ExtImage2dViewOf3dFn {}
+unsafe impl Sync for ExtImage2dViewOf3dFn {}
+impl ExtImage2dViewOf3dFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension394Fn {}
+        Self {}
     }
 }
-impl KhrExtension395Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_395\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_EXT_image_2d_view_of_3d'"]
+impl ImageCreateFlags {
+    #[doc = "Image is created with a layout where individual slices are capable of being used as 2D images"]
+    pub const TYPE_2D_VIEW_COMPATIBLE_EXT: Self = Self(0b10_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_image_2d_view_of_3d'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: Self = Self(1_000_393_000);
+}
+impl KhrPortabilityEnumerationFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_enumeration\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct KhrExtension395Fn {}
-unsafe impl Send for KhrExtension395Fn {}
-unsafe impl Sync for KhrExtension395Fn {}
-impl KhrExtension395Fn {
+pub struct KhrPortabilityEnumerationFn {}
+unsafe impl Send for KhrPortabilityEnumerationFn {}
+unsafe impl Sync for KhrPortabilityEnumerationFn {}
+impl KhrPortabilityEnumerationFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension395Fn {}
+        Self {}
     }
 }
-impl KhrExtension396Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_396\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_KHR_portability_enumeration'"]
+impl InstanceCreateFlags {
+    pub const ENUMERATE_PORTABILITY_KHR: Self = Self(0b1);
+}
+impl ExtShaderTileImageFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_tile_image\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct KhrExtension396Fn {}
-unsafe impl Send for KhrExtension396Fn {}
-unsafe impl Sync for KhrExtension396Fn {}
-impl KhrExtension396Fn {
+pub struct ExtShaderTileImageFn {}
+unsafe impl Send for ExtShaderTileImageFn {}
+unsafe impl Sync for ExtShaderTileImageFn {}
+impl ExtShaderTileImageFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension396Fn {}
+        Self {}
     }
 }
-impl NvExtension397Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_397\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_EXT_shader_tile_image'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: Self = Self(1_000_395_000);
+    pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: Self = Self(1_000_395_001);
+}
+impl ExtOpacityMicromapFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_opacity_micromap\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateMicromapEXT = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const MicromapCreateInfoEXT,
+    p_allocator: *const AllocationCallbacks,
+    p_micromap: *mut MicromapEXT,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyMicromapEXT = unsafe extern "system" fn(
+    device: Device,
+    micromap: MicromapEXT,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBuildMicromapsEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    info_count: u32,
+    p_infos: *const MicromapBuildInfoEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkBuildMicromapsEXT = unsafe extern "system" fn(
+    device: Device,
+    deferred_operation: DeferredOperationKHR,
+    info_count: u32,
+    p_infos: *const MicromapBuildInfoEXT,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCopyMicromapEXT = unsafe extern "system" fn(
+    device: Device,
+    deferred_operation: DeferredOperationKHR,
+    p_info: *const CopyMicromapInfoEXT,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCopyMicromapToMemoryEXT = unsafe extern "system" fn(
+    device: Device,
+    deferred_operation: DeferredOperationKHR,
+    p_info: *const CopyMicromapToMemoryInfoEXT,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCopyMemoryToMicromapEXT = unsafe extern "system" fn(
+    device: Device,
+    deferred_operation: DeferredOperationKHR,
+    p_info: *const CopyMemoryToMicromapInfoEXT,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkWriteMicromapsPropertiesEXT = unsafe extern "system" fn(
+    device: Device,
+    micromap_count: u32,
+    p_micromaps: *const MicromapEXT,
+    query_type: QueryType,
+    data_size: usize,
+    p_data: *mut c_void,
+    stride: usize,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyMicromapEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, p_info: *const CopyMicromapInfoEXT);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyMicromapToMemoryEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    p_info: *const CopyMicromapToMemoryInfoEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyMemoryToMicromapEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    p_info: *const CopyMemoryToMicromapInfoEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdWriteMicromapsPropertiesEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    micromap_count: u32,
+    p_micromaps: *const MicromapEXT,
+    query_type: QueryType,
+    query_pool: QueryPool,
+    first_query: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDeviceMicromapCompatibilityEXT = unsafe extern "system" fn(
+    device: Device,
+    p_version_info: *const MicromapVersionInfoEXT,
+    p_compatibility: *mut AccelerationStructureCompatibilityKHR,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetMicromapBuildSizesEXT = unsafe extern "system" fn(
+    device: Device,
+    build_type: AccelerationStructureBuildTypeKHR,
+    p_build_info: *const MicromapBuildInfoEXT,
+    p_size_info: *mut MicromapBuildSizesInfoEXT,
+);
 #[derive(Clone)]
-pub struct NvExtension397Fn {}
-unsafe impl Send for NvExtension397Fn {}
-unsafe impl Sync for NvExtension397Fn {}
-impl NvExtension397Fn {
+pub struct ExtOpacityMicromapFn {
+    pub create_micromap_ext: PFN_vkCreateMicromapEXT,
+    pub destroy_micromap_ext: PFN_vkDestroyMicromapEXT,
+    pub cmd_build_micromaps_ext: PFN_vkCmdBuildMicromapsEXT,
+    pub build_micromaps_ext: PFN_vkBuildMicromapsEXT,
+    pub copy_micromap_ext: PFN_vkCopyMicromapEXT,
+    pub copy_micromap_to_memory_ext: PFN_vkCopyMicromapToMemoryEXT,
+    pub copy_memory_to_micromap_ext: PFN_vkCopyMemoryToMicromapEXT,
+    pub write_micromaps_properties_ext: PFN_vkWriteMicromapsPropertiesEXT,
+    pub cmd_copy_micromap_ext: PFN_vkCmdCopyMicromapEXT,
+    pub cmd_copy_micromap_to_memory_ext: PFN_vkCmdCopyMicromapToMemoryEXT,
+    pub cmd_copy_memory_to_micromap_ext: PFN_vkCmdCopyMemoryToMicromapEXT,
+    pub cmd_write_micromaps_properties_ext: PFN_vkCmdWriteMicromapsPropertiesEXT,
+    pub get_device_micromap_compatibility_ext: PFN_vkGetDeviceMicromapCompatibilityEXT,
+    pub get_micromap_build_sizes_ext: PFN_vkGetMicromapBuildSizesEXT,
+}
+unsafe impl Send for ExtOpacityMicromapFn {}
+unsafe impl Sync for ExtOpacityMicromapFn {}
+impl ExtOpacityMicromapFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension397Fn {}
+        Self {
+            create_micromap_ext: unsafe {
+                unsafe extern "system" fn create_micromap_ext(
+                    _device: Device,
+                    _p_create_info: *const MicromapCreateInfoEXT,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_micromap: *mut MicromapEXT,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_micromap_ext)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMicromapEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_micromap_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_micromap_ext: unsafe {
+                unsafe extern "system" fn destroy_micromap_ext(
+                    _device: Device,
+                    _micromap: MicromapEXT,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_micromap_ext)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyMicromapEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_micromap_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_build_micromaps_ext: unsafe {
+                unsafe extern "system" fn cmd_build_micromaps_ext(
+                    _command_buffer: CommandBuffer,
+                    _info_count: u32,
+                    _p_infos: *const MicromapBuildInfoEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_build_micromaps_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBuildMicromapsEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_build_micromaps_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            build_micromaps_ext: unsafe {
+                unsafe extern "system" fn build_micromaps_ext(
+                    _device: Device,
+                    _deferred_operation: DeferredOperationKHR,
+                    _info_count: u32,
+                    _p_infos: *const MicromapBuildInfoEXT,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(build_micromaps_ext)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBuildMicromapsEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    build_micromaps_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            copy_micromap_ext: unsafe {
+                unsafe extern "system" fn copy_micromap_ext(
+                    _device: Device,
+                    _deferred_operation: DeferredOperationKHR,
+                    _p_info: *const CopyMicromapInfoEXT,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(copy_micromap_ext)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    copy_micromap_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            copy_micromap_to_memory_ext: unsafe {
+                unsafe extern "system" fn copy_micromap_to_memory_ext(
+                    _device: Device,
+                    _deferred_operation: DeferredOperationKHR,
+                    _p_info: *const CopyMicromapToMemoryInfoEXT,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(copy_micromap_to_memory_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapToMemoryEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    copy_micromap_to_memory_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            copy_memory_to_micromap_ext: unsafe {
+                unsafe extern "system" fn copy_memory_to_micromap_ext(
+                    _device: Device,
+                    _deferred_operation: DeferredOperationKHR,
+                    _p_info: *const CopyMemoryToMicromapInfoEXT,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(copy_memory_to_micromap_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToMicromapEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    copy_memory_to_micromap_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            write_micromaps_properties_ext: unsafe {
+                unsafe extern "system" fn write_micromaps_properties_ext(
+                    _device: Device,
+                    _micromap_count: u32,
+                    _p_micromaps: *const MicromapEXT,
+                    _query_type: QueryType,
+                    _data_size: usize,
+                    _p_data: *mut c_void,
+                    _stride: usize,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(write_micromaps_properties_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkWriteMicromapsPropertiesEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    write_micromaps_properties_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_micromap_ext: unsafe {
+                unsafe extern "system" fn cmd_copy_micromap_ext(
+                    _command_buffer: CommandBuffer,
+                    _p_info: *const CopyMicromapInfoEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_micromap_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_micromap_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_micromap_to_memory_ext: unsafe {
+                unsafe extern "system" fn cmd_copy_micromap_to_memory_ext(
+                    _command_buffer: CommandBuffer,
+                    _p_info: *const CopyMicromapToMemoryInfoEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_micromap_to_memory_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdCopyMicromapToMemoryEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_micromap_to_memory_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_memory_to_micromap_ext: unsafe {
+                unsafe extern "system" fn cmd_copy_memory_to_micromap_ext(
+                    _command_buffer: CommandBuffer,
+                    _p_info: *const CopyMemoryToMicromapInfoEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_memory_to_micromap_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdCopyMemoryToMicromapEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_memory_to_micromap_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_write_micromaps_properties_ext: unsafe {
+                unsafe extern "system" fn cmd_write_micromaps_properties_ext(
+                    _command_buffer: CommandBuffer,
+                    _micromap_count: u32,
+                    _p_micromaps: *const MicromapEXT,
+                    _query_type: QueryType,
+                    _query_pool: QueryPool,
+                    _first_query: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_write_micromaps_properties_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdWriteMicromapsPropertiesEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_write_micromaps_properties_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_micromap_compatibility_ext: unsafe {
+                unsafe extern "system" fn get_device_micromap_compatibility_ext(
+                    _device: Device,
+                    _p_version_info: *const MicromapVersionInfoEXT,
+                    _p_compatibility: *mut AccelerationStructureCompatibilityKHR,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_micromap_compatibility_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceMicromapCompatibilityEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_micromap_compatibility_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_micromap_build_sizes_ext: unsafe {
+                unsafe extern "system" fn get_micromap_build_sizes_ext(
+                    _device: Device,
+                    _build_type: AccelerationStructureBuildTypeKHR,
+                    _p_build_info: *const MicromapBuildInfoEXT,
+                    _p_size_info: *mut MicromapBuildSizesInfoEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_micromap_build_sizes_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetMicromapBuildSizesEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_micromap_build_sizes_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
-impl NvExtension398Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_398\0")
-            .expect("Wrong extension string")
+#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
+impl AccessFlags2 {
+    pub const MICROMAP_READ_EXT: Self =
+        Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const MICROMAP_WRITE_EXT: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
+impl BufferUsageFlags {
+    pub const MICROMAP_BUILD_INPUT_READ_ONLY_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
+    pub const MICROMAP_STORAGE_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
+impl BuildAccelerationStructureFlagsKHR {
+    pub const ALLOW_OPACITY_MICROMAP_UPDATE_EXT: Self = Self(0b100_0000);
+    pub const ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b1000_0000);
+    pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: Self = Self(0b1_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
+impl GeometryInstanceFlagsKHR {
+    pub const FORCE_OPACITY_MICROMAP_2_STATE_EXT: Self = Self(0b1_0000);
+    pub const DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b10_0000);
+}
+#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
+impl ObjectType {
+    pub const MICROMAP_EXT: Self = Self(1_000_396_000);
+}
+#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
+impl PipelineCreateFlags {
+    pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
+impl PipelineStageFlags2 {
+    pub const MICROMAP_BUILD_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
+impl QueryType {
+    pub const MICROMAP_SERIALIZATION_SIZE_EXT: Self = Self(1_000_396_000);
+    pub const MICROMAP_COMPACTED_SIZE_EXT: Self = Self(1_000_396_001);
+}
+#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
+impl StructureType {
+    pub const MICROMAP_BUILD_INFO_EXT: Self = Self(1_000_396_000);
+    pub const MICROMAP_VERSION_INFO_EXT: Self = Self(1_000_396_001);
+    pub const COPY_MICROMAP_INFO_EXT: Self = Self(1_000_396_002);
+    pub const COPY_MICROMAP_TO_MEMORY_INFO_EXT: Self = Self(1_000_396_003);
+    pub const COPY_MEMORY_TO_MICROMAP_INFO_EXT: Self = Self(1_000_396_004);
+    pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: Self = Self(1_000_396_005);
+    pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: Self = Self(1_000_396_006);
+    pub const MICROMAP_CREATE_INFO_EXT: Self = Self(1_000_396_007);
+    pub const MICROMAP_BUILD_SIZES_INFO_EXT: Self = Self(1_000_396_008);
+    pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: Self = Self(1_000_396_009);
+}
+impl NvDisplacementMicromapFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_displacement_micromap\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct NvExtension398Fn {}
-unsafe impl Send for NvExtension398Fn {}
-unsafe impl Sync for NvExtension398Fn {}
-impl NvExtension398Fn {
+pub struct NvDisplacementMicromapFn {}
+unsafe impl Send for NvDisplacementMicromapFn {}
+unsafe impl Sync for NvDisplacementMicromapFn {}
+impl NvDisplacementMicromapFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension398Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_NV_displacement_micromap'"]
+impl BuildAccelerationStructureFlagsKHR {
+    pub const ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV: Self = Self(0b10_0000_0000);
+}
+#[doc = "Generated from 'VK_NV_displacement_micromap'"]
+impl MicromapTypeEXT {
+    pub const DISPLACEMENT_MICROMAP_NV: Self = Self(1_000_397_000);
+}
+#[doc = "Generated from 'VK_NV_displacement_micromap'"]
+impl PipelineCreateFlags {
+    pub const RAY_TRACING_DISPLACEMENT_MICROMAP_NV: Self =
+        Self(0b1_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_NV_displacement_micromap'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: Self = Self(1_000_397_000);
+    pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: Self = Self(1_000_397_001);
+    pub const ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: Self = Self(1_000_397_002);
+}
 impl JuiceExtension399Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_JUICE_extension_399\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_399\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25215,13 +21616,13 @@ impl JuiceExtension399Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        JuiceExtension399Fn {}
+        Self {}
     }
 }
 impl JuiceExtension400Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_JUICE_extension_400\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_400\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25234,13 +21635,13 @@ impl JuiceExtension400Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        JuiceExtension400Fn {}
+        Self {}
     }
 }
 impl ExtLoadStoreOpNoneFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_load_store_op_none\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_load_store_op_none\0") }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -25253,7 +21654,7 @@ impl ExtLoadStoreOpNoneFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtLoadStoreOpNoneFn {}
+        Self {}
     }
 }
 #[doc = "Generated from 'VK_EXT_load_store_op_none'"]
@@ -25262,12 +21663,12 @@ impl AttachmentLoadOp {
 }
 #[doc = "Generated from 'VK_EXT_load_store_op_none'"]
 impl AttachmentStoreOp {
-    pub const NONE_EXT: Self = Self(1_000_301_000);
+    pub const NONE_EXT: Self = Self::NONE;
 }
 impl FbExtension402Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_FB_extension_402\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_402\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25280,13 +21681,13 @@ impl FbExtension402Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        FbExtension402Fn {}
+        Self {}
     }
 }
 impl FbExtension403Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_FB_extension_403\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_403\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25299,13 +21700,13 @@ impl FbExtension403Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        FbExtension403Fn {}
+        Self {}
     }
 }
 impl FbExtension404Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_FB_extension_404\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_404\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25318,32 +21719,108 @@ impl FbExtension404Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        FbExtension404Fn {}
+        Self {}
     }
 }
-impl HuaweiExtension405Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_405\0")
-            .expect("Wrong extension string")
+impl HuaweiClusterCullingShaderFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_cluster_culling_shader\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDrawClusterHUAWEI = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    group_count_x: u32,
+    group_count_y: u32,
+    group_count_z: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDrawClusterIndirectHUAWEI =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize);
 #[derive(Clone)]
-pub struct HuaweiExtension405Fn {}
-unsafe impl Send for HuaweiExtension405Fn {}
-unsafe impl Sync for HuaweiExtension405Fn {}
-impl HuaweiExtension405Fn {
+pub struct HuaweiClusterCullingShaderFn {
+    pub cmd_draw_cluster_huawei: PFN_vkCmdDrawClusterHUAWEI,
+    pub cmd_draw_cluster_indirect_huawei: PFN_vkCmdDrawClusterIndirectHUAWEI,
+}
+unsafe impl Send for HuaweiClusterCullingShaderFn {}
+unsafe impl Sync for HuaweiClusterCullingShaderFn {}
+impl HuaweiClusterCullingShaderFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        HuaweiExtension405Fn {}
+        Self {
+            cmd_draw_cluster_huawei: unsafe {
+                unsafe extern "system" fn cmd_draw_cluster_huawei(
+                    _command_buffer: CommandBuffer,
+                    _group_count_x: u32,
+                    _group_count_y: u32,
+                    _group_count_z: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_draw_cluster_huawei)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawClusterHUAWEI\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_cluster_huawei
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_draw_cluster_indirect_huawei: unsafe {
+                unsafe extern "system" fn cmd_draw_cluster_indirect_huawei(
+                    _command_buffer: CommandBuffer,
+                    _buffer: Buffer,
+                    _offset: DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_draw_cluster_indirect_huawei)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdDrawClusterIndirectHUAWEI\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_cluster_indirect_huawei
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
+#[doc = "Generated from 'VK_HUAWEI_cluster_culling_shader'"]
+impl PipelineStageFlags2 {
+    pub const CLUSTER_CULLING_SHADER_HUAWEI: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_HUAWEI_cluster_culling_shader'"]
+impl QueryPipelineStatisticFlags {
+    pub const CLUSTER_CULLING_SHADER_INVOCATIONS_HUAWEI: Self = Self(0b10_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_HUAWEI_cluster_culling_shader'"]
+impl ShaderStageFlags {
+    pub const CLUSTER_CULLING_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_HUAWEI_cluster_culling_shader'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: Self = Self(1_000_404_000);
+    pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: Self = Self(1_000_404_001);
+}
 impl HuaweiExtension406Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_406\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_406\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25356,13 +21833,13 @@ impl HuaweiExtension406Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        HuaweiExtension406Fn {}
+        Self {}
     }
 }
 impl GgpExtension407Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_407\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_407\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25375,13 +21852,13 @@ impl GgpExtension407Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GgpExtension407Fn {}
+        Self {}
     }
 }
 impl GgpExtension408Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_408\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_408\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25394,13 +21871,13 @@ impl GgpExtension408Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GgpExtension408Fn {}
+        Self {}
     }
 }
 impl GgpExtension409Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_409\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_409\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25413,13 +21890,13 @@ impl GgpExtension409Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GgpExtension409Fn {}
+        Self {}
     }
 }
 impl GgpExtension410Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_410\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_410\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25432,13 +21909,13 @@ impl GgpExtension410Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GgpExtension410Fn {}
+        Self {}
     }
 }
 impl GgpExtension411Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_GGP_extension_411\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_411\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25451,32 +21928,41 @@ impl GgpExtension411Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        GgpExtension411Fn {}
+        Self {}
     }
 }
-impl NvExtension412Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_412\0")
-            .expect("Wrong extension string")
+impl ExtBorderColorSwizzleFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_border_color_swizzle\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct NvExtension412Fn {}
-unsafe impl Send for NvExtension412Fn {}
-unsafe impl Sync for NvExtension412Fn {}
-impl NvExtension412Fn {
+pub struct ExtBorderColorSwizzleFn {}
+unsafe impl Send for ExtBorderColorSwizzleFn {}
+unsafe impl Sync for ExtBorderColorSwizzleFn {}
+impl ExtBorderColorSwizzleFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension412Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_EXT_border_color_swizzle'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: Self = Self(1_000_411_000);
+    pub const SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: Self = Self(1_000_411_001);
+}
 impl ExtPageableDeviceLocalMemoryFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_pageable_device_local_memory\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_pageable_device_local_memory\0",
+            )
+        }
     }
     pub const SPEC_VERSION: u32 = 1u32;
 }
@@ -25494,7 +21980,7 @@ impl ExtPageableDeviceLocalMemoryFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtPageableDeviceLocalMemoryFn {
+        Self {
             set_device_memory_priority_ext: unsafe {
                 unsafe extern "system" fn set_device_memory_priority_ext(
                     _device: Device,
@@ -25518,43 +22004,136 @@ impl ExtPageableDeviceLocalMemoryFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetDeviceMemoryPriorityEXT.html>"]
-    pub unsafe fn set_device_memory_priority_ext(
-        &self,
-        device: Device,
-        memory: DeviceMemory,
-        priority: f32,
-    ) {
-        (self.set_device_memory_priority_ext)(device, memory, priority)
-    }
 }
 #[doc = "Generated from 'VK_EXT_pageable_device_local_memory'"]
 impl StructureType {
     pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: Self = Self(1_000_412_000);
 }
-impl NvExtension414Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_NV_extension_414\0")
-            .expect("Wrong extension string")
+impl KhrMaintenance4Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance4\0") }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 2u32;
 }
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDeviceBufferMemoryRequirements = unsafe extern "system" fn(
+    device: Device,
+    p_info: *const DeviceBufferMemoryRequirements,
+    p_memory_requirements: *mut MemoryRequirements2,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDeviceImageMemoryRequirements = unsafe extern "system" fn(
+    device: Device,
+    p_info: *const DeviceImageMemoryRequirements,
+    p_memory_requirements: *mut MemoryRequirements2,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDeviceImageSparseMemoryRequirements = unsafe extern "system" fn(
+    device: Device,
+    p_info: *const DeviceImageMemoryRequirements,
+    p_sparse_memory_requirement_count: *mut u32,
+    p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
+);
 #[derive(Clone)]
-pub struct NvExtension414Fn {}
-unsafe impl Send for NvExtension414Fn {}
-unsafe impl Sync for NvExtension414Fn {}
-impl NvExtension414Fn {
+pub struct KhrMaintenance4Fn {
+    pub get_device_buffer_memory_requirements_khr: PFN_vkGetDeviceBufferMemoryRequirements,
+    pub get_device_image_memory_requirements_khr: PFN_vkGetDeviceImageMemoryRequirements,
+    pub get_device_image_sparse_memory_requirements_khr:
+        PFN_vkGetDeviceImageSparseMemoryRequirements,
+}
+unsafe impl Send for KhrMaintenance4Fn {}
+unsafe impl Sync for KhrMaintenance4Fn {}
+impl KhrMaintenance4Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        NvExtension414Fn {}
+        Self {
+            get_device_buffer_memory_requirements_khr: unsafe {
+                unsafe extern "system" fn get_device_buffer_memory_requirements_khr(
+                    _device: Device,
+                    _p_info: *const DeviceBufferMemoryRequirements,
+                    _p_memory_requirements: *mut MemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_buffer_memory_requirements_khr)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceBufferMemoryRequirementsKHR\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_buffer_memory_requirements_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_image_memory_requirements_khr: unsafe {
+                unsafe extern "system" fn get_device_image_memory_requirements_khr(
+                    _device: Device,
+                    _p_info: *const DeviceImageMemoryRequirements,
+                    _p_memory_requirements: *mut MemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_image_memory_requirements_khr)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceImageMemoryRequirementsKHR\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_image_memory_requirements_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_image_sparse_memory_requirements_khr: unsafe {
+                unsafe extern "system" fn get_device_image_sparse_memory_requirements_khr(
+                    _device: Device,
+                    _p_info: *const DeviceImageMemoryRequirements,
+                    _p_sparse_memory_requirement_count: *mut u32,
+                    _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_image_sparse_memory_requirements_khr)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceImageSparseMemoryRequirementsKHR\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_image_sparse_memory_requirements_khr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
+#[doc = "Generated from 'VK_KHR_maintenance4'"]
+impl ImageAspectFlags {
+    pub const NONE_KHR: Self = Self::NONE;
+}
+#[doc = "Generated from 'VK_KHR_maintenance4'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: Self =
+        Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
+    pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: Self =
+        Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
+    pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS;
+    pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS;
+}
 impl HuaweiExtension415Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_HUAWEI_extension_415\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_415\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25567,32 +22146,38 @@ impl HuaweiExtension415Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        HuaweiExtension415Fn {}
+        Self {}
     }
 }
-impl ArmExtension416Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_416\0")
-            .expect("Wrong extension string")
+impl ArmShaderCorePropertiesFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_shader_core_properties\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ArmExtension416Fn {}
-unsafe impl Send for ArmExtension416Fn {}
-unsafe impl Sync for ArmExtension416Fn {}
-impl ArmExtension416Fn {
+pub struct ArmShaderCorePropertiesFn {}
+unsafe impl Send for ArmShaderCorePropertiesFn {}
+unsafe impl Sync for ArmShaderCorePropertiesFn {}
+impl ArmShaderCorePropertiesFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ArmExtension416Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_ARM_shader_core_properties'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: Self = Self(1_000_415_000);
+}
 impl KhrExtension417Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_417\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_417\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25605,13 +22190,13 @@ impl KhrExtension417Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension417Fn {}
+        Self {}
     }
 }
 impl ArmExtension418Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_ARM_extension_418\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_418\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25624,32 +22209,39 @@ impl ArmExtension418Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ArmExtension418Fn {}
+        Self {}
     }
 }
-impl ExtExtension419Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_419\0")
-            .expect("Wrong extension string")
+impl ExtImageSlicedViewOf3dFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_sliced_view_of_3d\0")
+        }
     }
-    pub const SPEC_VERSION: u32 = 0u32;
+    pub const SPEC_VERSION: u32 = 1u32;
 }
 #[derive(Clone)]
-pub struct ExtExtension419Fn {}
-unsafe impl Send for ExtExtension419Fn {}
-unsafe impl Sync for ExtExtension419Fn {}
-impl ExtExtension419Fn {
+pub struct ExtImageSlicedViewOf3dFn {}
+unsafe impl Send for ExtImageSlicedViewOf3dFn {}
+unsafe impl Sync for ExtImageSlicedViewOf3dFn {}
+impl ExtImageSlicedViewOf3dFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension419Fn {}
+        Self {}
     }
 }
+#[doc = "Generated from 'VK_EXT_image_sliced_view_of_3d'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: Self = Self(1_000_418_000);
+    pub const IMAGE_VIEW_SLICED_CREATE_INFO_EXT: Self = Self(1_000_418_001);
+}
 impl ExtExtension420Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_420\0")
-            .expect("Wrong extension string")
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_420\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
@@ -25662,67 +22254,4992 @@ impl ExtExtension420Fn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension420Fn {}
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_extension_420'"]
+impl SwapchainCreateFlagsKHR {
+    pub const RESERVED_4_EXT: Self = Self(0b1_0000);
+}
+impl ValveDescriptorSetHostMappingFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_VALVE_descriptor_set_host_mapping\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn(
+    device: Device,
+    p_binding_reference: *const DescriptorSetBindingReferenceVALVE,
+    p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn(
+    device: Device,
+    descriptor_set: DescriptorSet,
+    pp_data: *mut *mut c_void,
+);
+#[derive(Clone)]
+pub struct ValveDescriptorSetHostMappingFn {
+    pub get_descriptor_set_layout_host_mapping_info_valve:
+        PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
+    pub get_descriptor_set_host_mapping_valve: PFN_vkGetDescriptorSetHostMappingVALVE,
+}
+unsafe impl Send for ValveDescriptorSetHostMappingFn {}
+unsafe impl Sync for ValveDescriptorSetHostMappingFn {}
+impl ValveDescriptorSetHostMappingFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            get_descriptor_set_layout_host_mapping_info_valve: unsafe {
+                unsafe extern "system" fn get_descriptor_set_layout_host_mapping_info_valve(
+                    _device: Device,
+                    _p_binding_reference: *const DescriptorSetBindingReferenceVALVE,
+                    _p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_descriptor_set_layout_host_mapping_info_valve)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDescriptorSetLayoutHostMappingInfoVALVE\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_descriptor_set_layout_host_mapping_info_valve
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_descriptor_set_host_mapping_valve: unsafe {
+                unsafe extern "system" fn get_descriptor_set_host_mapping_valve(
+                    _device: Device,
+                    _descriptor_set: DescriptorSet,
+                    _pp_data: *mut *mut c_void,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_descriptor_set_host_mapping_valve)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDescriptorSetHostMappingVALVE\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_descriptor_set_host_mapping_valve
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_VALVE_descriptor_set_host_mapping'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: Self =
+        Self(1_000_420_000);
+    pub const DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: Self = Self(1_000_420_001);
+    pub const DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: Self = Self(1_000_420_002);
+}
+impl ExtDepthClampZeroOneFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clamp_zero_one\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtDepthClampZeroOneFn {}
+unsafe impl Send for ExtDepthClampZeroOneFn {}
+unsafe impl Sync for ExtDepthClampZeroOneFn {}
+impl ExtDepthClampZeroOneFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_depth_clamp_zero_one'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: Self = Self(1_000_421_000);
+}
+impl ExtNonSeamlessCubeMapFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_non_seamless_cube_map\0")
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtNonSeamlessCubeMapFn {}
+unsafe impl Send for ExtNonSeamlessCubeMapFn {}
+unsafe impl Sync for ExtNonSeamlessCubeMapFn {}
+impl ExtNonSeamlessCubeMapFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"]
+impl SamplerCreateFlags {
+    pub const NON_SEAMLESS_CUBE_MAP_EXT: Self = Self(0b100);
+}
+#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: Self = Self(1_000_422_000);
+}
+impl ArmExtension424Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_424\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ArmExtension424Fn {}
+unsafe impl Send for ArmExtension424Fn {}
+unsafe impl Sync for ArmExtension424Fn {}
+impl ArmExtension424Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ArmExtension425Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_425\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ArmExtension425Fn {}
+unsafe impl Send for ArmExtension425Fn {}
+unsafe impl Sync for ArmExtension425Fn {}
+impl ArmExtension425Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QcomFragmentDensityMapOffsetFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_QCOM_fragment_density_map_offset\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct QcomFragmentDensityMapOffsetFn {}
+unsafe impl Send for QcomFragmentDensityMapOffsetFn {}
+unsafe impl Sync for QcomFragmentDensityMapOffsetFn {}
+impl QcomFragmentDensityMapOffsetFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"]
+impl ImageCreateFlags {
+    pub const FRAGMENT_DENSITY_MAP_OFFSET_QCOM: Self = Self(0b1000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: Self = Self(1_000_425_000);
+    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: Self =
+        Self(1_000_425_001);
+    pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: Self = Self(1_000_425_002);
+}
+impl NvCopyMemoryIndirectFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_copy_memory_indirect\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyMemoryIndirectNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    copy_buffer_address: DeviceAddress,
+    copy_count: u32,
+    stride: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyMemoryToImageIndirectNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    copy_buffer_address: DeviceAddress,
+    copy_count: u32,
+    stride: u32,
+    dst_image: Image,
+    dst_image_layout: ImageLayout,
+    p_image_subresources: *const ImageSubresourceLayers,
+);
+#[derive(Clone)]
+pub struct NvCopyMemoryIndirectFn {
+    pub cmd_copy_memory_indirect_nv: PFN_vkCmdCopyMemoryIndirectNV,
+    pub cmd_copy_memory_to_image_indirect_nv: PFN_vkCmdCopyMemoryToImageIndirectNV,
+}
+unsafe impl Send for NvCopyMemoryIndirectFn {}
+unsafe impl Sync for NvCopyMemoryIndirectFn {}
+impl NvCopyMemoryIndirectFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            cmd_copy_memory_indirect_nv: unsafe {
+                unsafe extern "system" fn cmd_copy_memory_indirect_nv(
+                    _command_buffer: CommandBuffer,
+                    _copy_buffer_address: DeviceAddress,
+                    _copy_count: u32,
+                    _stride: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_memory_indirect_nv)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMemoryIndirectNV\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_memory_indirect_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_memory_to_image_indirect_nv: unsafe {
+                unsafe extern "system" fn cmd_copy_memory_to_image_indirect_nv(
+                    _command_buffer: CommandBuffer,
+                    _copy_buffer_address: DeviceAddress,
+                    _copy_count: u32,
+                    _stride: u32,
+                    _dst_image: Image,
+                    _dst_image_layout: ImageLayout,
+                    _p_image_subresources: *const ImageSubresourceLayers,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_memory_to_image_indirect_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdCopyMemoryToImageIndirectNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_memory_to_image_indirect_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_NV_copy_memory_indirect'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: Self = Self(1_000_426_000);
+    pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: Self = Self(1_000_426_001);
+}
+impl NvMemoryDecompressionFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_memory_decompression\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDecompressMemoryNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    decompress_region_count: u32,
+    p_decompress_memory_regions: *const DecompressMemoryRegionNV,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDecompressMemoryIndirectCountNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    indirect_commands_address: DeviceAddress,
+    indirect_commands_count_address: DeviceAddress,
+    stride: u32,
+);
+#[derive(Clone)]
+pub struct NvMemoryDecompressionFn {
+    pub cmd_decompress_memory_nv: PFN_vkCmdDecompressMemoryNV,
+    pub cmd_decompress_memory_indirect_count_nv: PFN_vkCmdDecompressMemoryIndirectCountNV,
+}
+unsafe impl Send for NvMemoryDecompressionFn {}
+unsafe impl Sync for NvMemoryDecompressionFn {}
+impl NvMemoryDecompressionFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            cmd_decompress_memory_nv: unsafe {
+                unsafe extern "system" fn cmd_decompress_memory_nv(
+                    _command_buffer: CommandBuffer,
+                    _decompress_region_count: u32,
+                    _p_decompress_memory_regions: *const DecompressMemoryRegionNV,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_decompress_memory_nv)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDecompressMemoryNV\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_decompress_memory_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_decompress_memory_indirect_count_nv: unsafe {
+                unsafe extern "system" fn cmd_decompress_memory_indirect_count_nv(
+                    _command_buffer: CommandBuffer,
+                    _indirect_commands_address: DeviceAddress,
+                    _indirect_commands_count_address: DeviceAddress,
+                    _stride: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_decompress_memory_indirect_count_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdDecompressMemoryIndirectCountNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_decompress_memory_indirect_count_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_NV_memory_decompression'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: Self = Self(1_000_427_000);
+    pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: Self = Self(1_000_427_001);
+}
+impl NvExtension429Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_429\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension429Fn {}
+unsafe impl Send for NvExtension429Fn {}
+unsafe impl Sync for NvExtension429Fn {}
+impl NvExtension429Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl NvExtension430Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_430\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension430Fn {}
+unsafe impl Send for NvExtension430Fn {}
+unsafe impl Sync for NvExtension430Fn {}
+impl NvExtension430Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl NvLinearColorAttachmentFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_linear_color_attachment\0")
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct NvLinearColorAttachmentFn {}
+unsafe impl Send for NvLinearColorAttachmentFn {}
+unsafe impl Sync for NvLinearColorAttachmentFn {}
+impl NvLinearColorAttachmentFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_NV_linear_color_attachment'"]
+impl FormatFeatureFlags2 {
+    #[doc = "Format support linear image as render target, it cannot be mixed with non linear attachment"]
+    pub const LINEAR_COLOR_ATTACHMENT_NV: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_NV_linear_color_attachment'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: Self = Self(1_000_430_000);
+}
+impl NvExtension432Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_432\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension432Fn {}
+unsafe impl Send for NvExtension432Fn {}
+unsafe impl Sync for NvExtension432Fn {}
+impl NvExtension432Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl NvExtension433Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_433\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension433Fn {}
+unsafe impl Send for NvExtension433Fn {}
+unsafe impl Sync for NvExtension433Fn {}
+impl NvExtension433Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
     }
 }
-impl KhrExtension421Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_KHR_extension_421\0")
-            .expect("Wrong extension string")
+impl GoogleSurfacelessQueryFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_surfaceless_query\0") }
+    }
+    pub const SPEC_VERSION: u32 = 2u32;
+}
+#[derive(Clone)]
+pub struct GoogleSurfacelessQueryFn {}
+unsafe impl Send for GoogleSurfacelessQueryFn {}
+unsafe impl Sync for GoogleSurfacelessQueryFn {}
+impl GoogleSurfacelessQueryFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl KhrExtension435Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_435\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
 #[derive(Clone)]
-pub struct KhrExtension421Fn {}
-unsafe impl Send for KhrExtension421Fn {}
-unsafe impl Sync for KhrExtension421Fn {}
-impl KhrExtension421Fn {
+pub struct KhrExtension435Fn {}
+unsafe impl Send for KhrExtension435Fn {}
+unsafe impl Sync for KhrExtension435Fn {}
+impl KhrExtension435Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        KhrExtension421Fn {}
+        Self {}
     }
 }
-impl ExtExtension422Fn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_extension_422\0")
-            .expect("Wrong extension string")
+impl ExtExtension437Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_437\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
 #[derive(Clone)]
-pub struct ExtExtension422Fn {}
-unsafe impl Send for ExtExtension422Fn {}
-unsafe impl Sync for ExtExtension422Fn {}
-impl ExtExtension422Fn {
+pub struct ExtExtension437Fn {}
+unsafe impl Send for ExtExtension437Fn {}
+unsafe impl Sync for ExtExtension437Fn {}
+impl ExtExtension437Fn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtExtension422Fn {}
+        Self {}
     }
 }
-impl ExtDisableCubeMapWrapFn {
-    pub fn name() -> &'static ::std::ffi::CStr {
-        ::std::ffi::CStr::from_bytes_with_nul(b"VK_EXT_disable_cube_map_wrap\0")
-            .expect("Wrong extension string")
+impl ExtImageCompressionControlSwapchainFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_image_compression_control_swapchain\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtImageCompressionControlSwapchainFn {}
+unsafe impl Send for ExtImageCompressionControlSwapchainFn {}
+unsafe impl Sync for ExtImageCompressionControlSwapchainFn {}
+impl ExtImageCompressionControlSwapchainFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_image_compression_control_swapchain'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: Self =
+        Self(1_000_437_000);
+}
+impl SecExtension439Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_439\0") }
     }
     pub const SPEC_VERSION: u32 = 0u32;
 }
 #[derive(Clone)]
-pub struct ExtDisableCubeMapWrapFn {}
-unsafe impl Send for ExtDisableCubeMapWrapFn {}
-unsafe impl Sync for ExtDisableCubeMapWrapFn {}
-impl ExtDisableCubeMapWrapFn {
+pub struct SecExtension439Fn {}
+unsafe impl Send for SecExtension439Fn {}
+unsafe impl Sync for SecExtension439Fn {}
+impl SecExtension439Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QcomExtension440Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_440\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct QcomExtension440Fn {}
+unsafe impl Send for QcomExtension440Fn {}
+unsafe impl Sync for QcomExtension440Fn {}
+impl QcomExtension440Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_QCOM_extension_440'"]
+impl DeviceQueueCreateFlags {
+    pub const RESERVED_1_QCOM: Self = Self(0b10);
+}
+#[doc = "Generated from 'VK_QCOM_extension_440'"]
+impl QueueFlags {
+    pub const RESERVED_7_QCOM: Self = Self(0b1000_0000);
+}
+impl QcomImageProcessingFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_image_processing\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct QcomImageProcessingFn {}
+unsafe impl Send for QcomImageProcessingFn {}
+unsafe impl Sync for QcomImageProcessingFn {}
+impl QcomImageProcessingFn {
     pub fn load<F>(mut _f: F) -> Self
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        ExtDisableCubeMapWrapFn {}
+        Self {}
     }
 }
-#[doc = "Generated from 'VK_EXT_disable_cube_map_wrap'"]
+#[doc = "Generated from 'VK_QCOM_image_processing'"]
+impl DescriptorType {
+    pub const SAMPLE_WEIGHT_IMAGE_QCOM: Self = Self(1_000_440_000);
+    pub const BLOCK_MATCH_IMAGE_QCOM: Self = Self(1_000_440_001);
+}
+#[doc = "Generated from 'VK_QCOM_image_processing'"]
+impl FormatFeatureFlags2 {
+    pub const WEIGHT_IMAGE_QCOM: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const WEIGHT_SAMPLED_IMAGE_QCOM: Self =
+        Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const BLOCK_MATCHING_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const BOX_FILTER_SAMPLED_QCOM: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_QCOM_image_processing'"]
+impl ImageUsageFlags {
+    pub const SAMPLE_WEIGHT_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000);
+    pub const SAMPLE_BLOCK_MATCH_QCOM: Self = Self(0b10_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_QCOM_image_processing'"]
 impl SamplerCreateFlags {
-    pub const RESERVED_2_EXT: Self = Self(0b100);
+    pub const IMAGE_PROCESSING_QCOM: Self = Self(0b1_0000);
+}
+#[doc = "Generated from 'VK_QCOM_image_processing'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: Self = Self(1_000_440_000);
+    pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: Self = Self(1_000_440_001);
+    pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: Self = Self(1_000_440_002);
+}
+impl CoreaviExtension442Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_442\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct CoreaviExtension442Fn {}
+unsafe impl Send for CoreaviExtension442Fn {}
+unsafe impl Sync for CoreaviExtension442Fn {}
+impl CoreaviExtension442Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl CoreaviExtension443Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_443\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct CoreaviExtension443Fn {}
+unsafe impl Send for CoreaviExtension443Fn {}
+unsafe impl Sync for CoreaviExtension443Fn {}
+impl CoreaviExtension443Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl CoreaviExtension444Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_444\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct CoreaviExtension444Fn {}
+unsafe impl Send for CoreaviExtension444Fn {}
+unsafe impl Sync for CoreaviExtension444Fn {}
+impl CoreaviExtension444Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_COREAVI_extension_444'"]
+impl CommandPoolResetFlags {
+    pub const RESERVED_1_COREAVI: Self = Self(0b10);
+}
+impl CoreaviExtension445Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_445\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct CoreaviExtension445Fn {}
+unsafe impl Send for CoreaviExtension445Fn {}
+unsafe impl Sync for CoreaviExtension445Fn {}
+impl CoreaviExtension445Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl CoreaviExtension446Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_446\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct CoreaviExtension446Fn {}
+unsafe impl Send for CoreaviExtension446Fn {}
+unsafe impl Sync for CoreaviExtension446Fn {}
+impl CoreaviExtension446Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl CoreaviExtension447Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_447\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct CoreaviExtension447Fn {}
+unsafe impl Send for CoreaviExtension447Fn {}
+unsafe impl Sync for CoreaviExtension447Fn {}
+impl CoreaviExtension447Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl SecExtension448Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_448\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct SecExtension448Fn {}
+unsafe impl Send for SecExtension448Fn {}
+unsafe impl Sync for SecExtension448Fn {}
+impl SecExtension448Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl SecExtension449Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_449\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct SecExtension449Fn {}
+unsafe impl Send for SecExtension449Fn {}
+unsafe impl Sync for SecExtension449Fn {}
+impl SecExtension449Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl SecExtension450Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_450\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct SecExtension450Fn {}
+unsafe impl Send for SecExtension450Fn {}
+unsafe impl Sync for SecExtension450Fn {}
+impl SecExtension450Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl SecExtension451Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_451\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct SecExtension451Fn {}
+unsafe impl Send for SecExtension451Fn {}
+unsafe impl Sync for SecExtension451Fn {}
+impl SecExtension451Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl NvExtension452Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_452\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension452Fn {}
+unsafe impl Send for NvExtension452Fn {}
+unsafe impl Sync for NvExtension452Fn {}
+impl NvExtension452Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ArmExtension453Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_453\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ArmExtension453Fn {}
+unsafe impl Send for ArmExtension453Fn {}
+unsafe impl Sync for ArmExtension453Fn {}
+impl ArmExtension453Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_ARM_extension_453'"]
+impl AccessFlags2 {
+    pub const RESERVED_49_ARM: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const RESERVED_50_ARM: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_ARM_extension_453'"]
+impl PipelineStageFlags2 {
+    pub const RESERVED_43_ARM: Self =
+        Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_ARM_extension_453'"]
+impl QueueFlags {
+    pub const RESERVED_11_ARM: Self = Self(0b1000_0000_0000);
+}
+impl GoogleExtension454Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_454\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct GoogleExtension454Fn {}
+unsafe impl Send for GoogleExtension454Fn {}
+unsafe impl Sync for GoogleExtension454Fn {}
+impl GoogleExtension454Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl GoogleExtension455Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_455\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct GoogleExtension455Fn {}
+unsafe impl Send for GoogleExtension455Fn {}
+unsafe impl Sync for GoogleExtension455Fn {}
+impl GoogleExtension455Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtendedDynamicState3Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state3\0")
+        }
+    }
+    pub const SPEC_VERSION: u32 = 2u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetTessellationDomainOriginEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    domain_origin: TessellationDomainOrigin,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetDepthClampEnableEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clamp_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetPolygonModeEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, polygon_mode: PolygonMode);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetRasterizationSamplesEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    rasterization_samples: SampleCountFlags,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetSampleMaskEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    samples: SampleCountFlags,
+    p_sample_mask: *const SampleMask,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetAlphaToCoverageEnableEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_coverage_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetAlphaToOneEnableEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_one_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetLogicOpEnableEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetColorBlendEnableEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    first_attachment: u32,
+    attachment_count: u32,
+    p_color_blend_enables: *const Bool32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetColorBlendEquationEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    first_attachment: u32,
+    attachment_count: u32,
+    p_color_blend_equations: *const ColorBlendEquationEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetColorWriteMaskEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    first_attachment: u32,
+    attachment_count: u32,
+    p_color_write_masks: *const ColorComponentFlags,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetRasterizationStreamEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, rasterization_stream: u32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetConservativeRasterizationModeEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    conservative_rasterization_mode: ConservativeRasterizationModeEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    extra_primitive_overestimation_size: f32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetDepthClipEnableEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clip_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetSampleLocationsEnableEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, sample_locations_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetColorBlendAdvancedEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    first_attachment: u32,
+    attachment_count: u32,
+    p_color_blend_advanced: *const ColorBlendAdvancedEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetProvokingVertexModeEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    provoking_vertex_mode: ProvokingVertexModeEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetLineRasterizationModeEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    line_rasterization_mode: LineRasterizationModeEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetLineStippleEnableEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, stippled_line_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetDepthClipNegativeOneToOneEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, negative_one_to_one: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetViewportWScalingEnableNV =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, viewport_w_scaling_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetViewportSwizzleNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    first_viewport: u32,
+    viewport_count: u32,
+    p_viewport_swizzles: *const ViewportSwizzleNV,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetCoverageToColorEnableNV =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetCoverageToColorLocationNV =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_location: u32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetCoverageModulationModeNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    coverage_modulation_mode: CoverageModulationModeNV,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetCoverageModulationTableEnableNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    coverage_modulation_table_enable: Bool32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetCoverageModulationTableNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    coverage_modulation_table_count: u32,
+    p_coverage_modulation_table: *const f32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetShadingRateImageEnableNV =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, shading_rate_image_enable: Bool32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetRepresentativeFragmentTestEnableNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    representative_fragment_test_enable: Bool32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetCoverageReductionModeNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    coverage_reduction_mode: CoverageReductionModeNV,
+);
+#[derive(Clone)]
+pub struct ExtExtendedDynamicState3Fn {
+    pub cmd_set_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEXT,
+    pub cmd_set_depth_clamp_enable_ext: PFN_vkCmdSetDepthClampEnableEXT,
+    pub cmd_set_polygon_mode_ext: PFN_vkCmdSetPolygonModeEXT,
+    pub cmd_set_rasterization_samples_ext: PFN_vkCmdSetRasterizationSamplesEXT,
+    pub cmd_set_sample_mask_ext: PFN_vkCmdSetSampleMaskEXT,
+    pub cmd_set_alpha_to_coverage_enable_ext: PFN_vkCmdSetAlphaToCoverageEnableEXT,
+    pub cmd_set_alpha_to_one_enable_ext: PFN_vkCmdSetAlphaToOneEnableEXT,
+    pub cmd_set_logic_op_enable_ext: PFN_vkCmdSetLogicOpEnableEXT,
+    pub cmd_set_color_blend_enable_ext: PFN_vkCmdSetColorBlendEnableEXT,
+    pub cmd_set_color_blend_equation_ext: PFN_vkCmdSetColorBlendEquationEXT,
+    pub cmd_set_color_write_mask_ext: PFN_vkCmdSetColorWriteMaskEXT,
+    pub cmd_set_rasterization_stream_ext: PFN_vkCmdSetRasterizationStreamEXT,
+    pub cmd_set_conservative_rasterization_mode_ext: PFN_vkCmdSetConservativeRasterizationModeEXT,
+    pub cmd_set_extra_primitive_overestimation_size_ext:
+        PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
+    pub cmd_set_depth_clip_enable_ext: PFN_vkCmdSetDepthClipEnableEXT,
+    pub cmd_set_sample_locations_enable_ext: PFN_vkCmdSetSampleLocationsEnableEXT,
+    pub cmd_set_color_blend_advanced_ext: PFN_vkCmdSetColorBlendAdvancedEXT,
+    pub cmd_set_provoking_vertex_mode_ext: PFN_vkCmdSetProvokingVertexModeEXT,
+    pub cmd_set_line_rasterization_mode_ext: PFN_vkCmdSetLineRasterizationModeEXT,
+    pub cmd_set_line_stipple_enable_ext: PFN_vkCmdSetLineStippleEnableEXT,
+    pub cmd_set_depth_clip_negative_one_to_one_ext: PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
+    pub cmd_set_viewport_w_scaling_enable_nv: PFN_vkCmdSetViewportWScalingEnableNV,
+    pub cmd_set_viewport_swizzle_nv: PFN_vkCmdSetViewportSwizzleNV,
+    pub cmd_set_coverage_to_color_enable_nv: PFN_vkCmdSetCoverageToColorEnableNV,
+    pub cmd_set_coverage_to_color_location_nv: PFN_vkCmdSetCoverageToColorLocationNV,
+    pub cmd_set_coverage_modulation_mode_nv: PFN_vkCmdSetCoverageModulationModeNV,
+    pub cmd_set_coverage_modulation_table_enable_nv: PFN_vkCmdSetCoverageModulationTableEnableNV,
+    pub cmd_set_coverage_modulation_table_nv: PFN_vkCmdSetCoverageModulationTableNV,
+    pub cmd_set_shading_rate_image_enable_nv: PFN_vkCmdSetShadingRateImageEnableNV,
+    pub cmd_set_representative_fragment_test_enable_nv:
+        PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
+    pub cmd_set_coverage_reduction_mode_nv: PFN_vkCmdSetCoverageReductionModeNV,
+}
+unsafe impl Send for ExtExtendedDynamicState3Fn {}
+unsafe impl Sync for ExtExtendedDynamicState3Fn {}
+impl ExtExtendedDynamicState3Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            cmd_set_tessellation_domain_origin_ext: unsafe {
+                unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext(
+                    _command_buffer: CommandBuffer,
+                    _domain_origin: TessellationDomainOrigin,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_tessellation_domain_origin_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetTessellationDomainOriginEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_tessellation_domain_origin_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_clamp_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_clamp_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _depth_clamp_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_clamp_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthClampEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_clamp_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_polygon_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_polygon_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _polygon_mode: PolygonMode,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_polygon_mode_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_polygon_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_rasterization_samples_ext: unsafe {
+                unsafe extern "system" fn cmd_set_rasterization_samples_ext(
+                    _command_buffer: CommandBuffer,
+                    _rasterization_samples: SampleCountFlags,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_rasterization_samples_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetRasterizationSamplesEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_rasterization_samples_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_sample_mask_ext: unsafe {
+                unsafe extern "system" fn cmd_set_sample_mask_ext(
+                    _command_buffer: CommandBuffer,
+                    _samples: SampleCountFlags,
+                    _p_sample_mask: *const SampleMask,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_sample_mask_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_sample_mask_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_alpha_to_coverage_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _alpha_to_coverage_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_alpha_to_coverage_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetAlphaToCoverageEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_alpha_to_coverage_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_alpha_to_one_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _alpha_to_one_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_alpha_to_one_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetAlphaToOneEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_alpha_to_one_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_logic_op_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_logic_op_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _logic_op_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_logic_op_enable_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_logic_op_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_color_blend_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_color_blend_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _first_attachment: u32,
+                    _attachment_count: u32,
+                    _p_color_blend_enables: *const Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_color_blend_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetColorBlendEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_color_blend_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_color_blend_equation_ext: unsafe {
+                unsafe extern "system" fn cmd_set_color_blend_equation_ext(
+                    _command_buffer: CommandBuffer,
+                    _first_attachment: u32,
+                    _attachment_count: u32,
+                    _p_color_blend_equations: *const ColorBlendEquationEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_color_blend_equation_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetColorBlendEquationEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_color_blend_equation_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_color_write_mask_ext: unsafe {
+                unsafe extern "system" fn cmd_set_color_write_mask_ext(
+                    _command_buffer: CommandBuffer,
+                    _first_attachment: u32,
+                    _attachment_count: u32,
+                    _p_color_write_masks: *const ColorComponentFlags,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_color_write_mask_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_color_write_mask_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_rasterization_stream_ext: unsafe {
+                unsafe extern "system" fn cmd_set_rasterization_stream_ext(
+                    _command_buffer: CommandBuffer,
+                    _rasterization_stream: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_rasterization_stream_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetRasterizationStreamEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_rasterization_stream_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_conservative_rasterization_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _conservative_rasterization_mode: ConservativeRasterizationModeEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_conservative_rasterization_mode_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetConservativeRasterizationModeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_conservative_rasterization_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_extra_primitive_overestimation_size_ext: unsafe {
+                unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext(
+                    _command_buffer: CommandBuffer,
+                    _extra_primitive_overestimation_size: f32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_extra_primitive_overestimation_size_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_extra_primitive_overestimation_size_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_clip_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_clip_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _depth_clip_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_clip_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthClipEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_clip_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_sample_locations_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_sample_locations_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _sample_locations_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_sample_locations_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetSampleLocationsEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_sample_locations_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_color_blend_advanced_ext: unsafe {
+                unsafe extern "system" fn cmd_set_color_blend_advanced_ext(
+                    _command_buffer: CommandBuffer,
+                    _first_attachment: u32,
+                    _attachment_count: u32,
+                    _p_color_blend_advanced: *const ColorBlendAdvancedEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_color_blend_advanced_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetColorBlendAdvancedEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_color_blend_advanced_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_provoking_vertex_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _provoking_vertex_mode: ProvokingVertexModeEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_provoking_vertex_mode_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetProvokingVertexModeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_provoking_vertex_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_line_rasterization_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_line_rasterization_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _line_rasterization_mode: LineRasterizationModeEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_line_rasterization_mode_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetLineRasterizationModeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_line_rasterization_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_line_stipple_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_line_stipple_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _stippled_line_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_line_stipple_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetLineStippleEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_line_stipple_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_clip_negative_one_to_one_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext(
+                    _command_buffer: CommandBuffer,
+                    _negative_one_to_one: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_clip_negative_one_to_one_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthClipNegativeOneToOneEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_clip_negative_one_to_one_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_viewport_w_scaling_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _viewport_w_scaling_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_viewport_w_scaling_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetViewportWScalingEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_viewport_w_scaling_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_viewport_swizzle_nv: unsafe {
+                unsafe extern "system" fn cmd_set_viewport_swizzle_nv(
+                    _command_buffer: CommandBuffer,
+                    _first_viewport: u32,
+                    _viewport_count: u32,
+                    _p_viewport_swizzles: *const ViewportSwizzleNV,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_viewport_swizzle_nv)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_viewport_swizzle_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_to_color_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_to_color_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_to_color_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageToColorEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_to_color_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_to_color_location_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_to_color_location_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_to_color_location: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_to_color_location_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageToColorLocationNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_to_color_location_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_modulation_mode_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_modulation_mode: CoverageModulationModeNV,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_modulation_mode_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageModulationModeNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_modulation_mode_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_modulation_table_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_modulation_table_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_modulation_table_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageModulationTableEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_modulation_table_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_modulation_table_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_modulation_table_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_modulation_table_count: u32,
+                    _p_coverage_modulation_table: *const f32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_modulation_table_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageModulationTableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_modulation_table_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_shading_rate_image_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _shading_rate_image_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_shading_rate_image_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetShadingRateImageEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_shading_rate_image_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_representative_fragment_test_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _representative_fragment_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_representative_fragment_test_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetRepresentativeFragmentTestEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_representative_fragment_test_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_reduction_mode_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_reduction_mode: CoverageReductionModeNV,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_reduction_mode_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageReductionModeNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_reduction_mode_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"]
+impl DynamicState {
+    pub const TESSELLATION_DOMAIN_ORIGIN_EXT: Self = Self(1_000_455_002);
+    pub const DEPTH_CLAMP_ENABLE_EXT: Self = Self(1_000_455_003);
+    pub const POLYGON_MODE_EXT: Self = Self(1_000_455_004);
+    pub const RASTERIZATION_SAMPLES_EXT: Self = Self(1_000_455_005);
+    pub const SAMPLE_MASK_EXT: Self = Self(1_000_455_006);
+    pub const ALPHA_TO_COVERAGE_ENABLE_EXT: Self = Self(1_000_455_007);
+    pub const ALPHA_TO_ONE_ENABLE_EXT: Self = Self(1_000_455_008);
+    pub const LOGIC_OP_ENABLE_EXT: Self = Self(1_000_455_009);
+    pub const COLOR_BLEND_ENABLE_EXT: Self = Self(1_000_455_010);
+    pub const COLOR_BLEND_EQUATION_EXT: Self = Self(1_000_455_011);
+    pub const COLOR_WRITE_MASK_EXT: Self = Self(1_000_455_012);
+    pub const RASTERIZATION_STREAM_EXT: Self = Self(1_000_455_013);
+    pub const CONSERVATIVE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_014);
+    pub const EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: Self = Self(1_000_455_015);
+    pub const DEPTH_CLIP_ENABLE_EXT: Self = Self(1_000_455_016);
+    pub const SAMPLE_LOCATIONS_ENABLE_EXT: Self = Self(1_000_455_017);
+    pub const COLOR_BLEND_ADVANCED_EXT: Self = Self(1_000_455_018);
+    pub const PROVOKING_VERTEX_MODE_EXT: Self = Self(1_000_455_019);
+    pub const LINE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_020);
+    pub const LINE_STIPPLE_ENABLE_EXT: Self = Self(1_000_455_021);
+    pub const DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: Self = Self(1_000_455_022);
+    pub const VIEWPORT_W_SCALING_ENABLE_NV: Self = Self(1_000_455_023);
+    pub const VIEWPORT_SWIZZLE_NV: Self = Self(1_000_455_024);
+    pub const COVERAGE_TO_COLOR_ENABLE_NV: Self = Self(1_000_455_025);
+    pub const COVERAGE_TO_COLOR_LOCATION_NV: Self = Self(1_000_455_026);
+    pub const COVERAGE_MODULATION_MODE_NV: Self = Self(1_000_455_027);
+    pub const COVERAGE_MODULATION_TABLE_ENABLE_NV: Self = Self(1_000_455_028);
+    pub const COVERAGE_MODULATION_TABLE_NV: Self = Self(1_000_455_029);
+    pub const SHADING_RATE_IMAGE_ENABLE_NV: Self = Self(1_000_455_030);
+    pub const REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: Self = Self(1_000_455_031);
+    pub const COVERAGE_REDUCTION_MODE_NV: Self = Self(1_000_455_032);
+}
+#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: Self = Self(1_000_455_000);
+    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: Self = Self(1_000_455_001);
+}
+impl ExtExtension457Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_457\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension457Fn {}
+unsafe impl Send for ExtExtension457Fn {}
+unsafe impl Sync for ExtExtension457Fn {}
+impl ExtExtension457Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension458Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_458\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension458Fn {}
+unsafe impl Send for ExtExtension458Fn {}
+unsafe impl Sync for ExtExtension458Fn {}
+impl ExtExtension458Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtSubpassMergeFeedbackFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subpass_merge_feedback\0")
+        }
+    }
+    pub const SPEC_VERSION: u32 = 2u32;
+}
+#[derive(Clone)]
+pub struct ExtSubpassMergeFeedbackFn {}
+unsafe impl Send for ExtSubpassMergeFeedbackFn {}
+unsafe impl Sync for ExtSubpassMergeFeedbackFn {}
+impl ExtSubpassMergeFeedbackFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_subpass_merge_feedback'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: Self = Self(1_000_458_000);
+    pub const RENDER_PASS_CREATION_CONTROL_EXT: Self = Self(1_000_458_001);
+    pub const RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_002);
+    pub const RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_003);
+}
+impl LunargDirectDriverLoadingFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_LUNARG_direct_driver_loading\0")
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct LunargDirectDriverLoadingFn {}
+unsafe impl Send for LunargDirectDriverLoadingFn {}
+unsafe impl Sync for LunargDirectDriverLoadingFn {}
+impl LunargDirectDriverLoadingFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_LUNARG_direct_driver_loading'"]
+impl StructureType {
+    pub const DIRECT_DRIVER_LOADING_INFO_LUNARG: Self = Self(1_000_459_000);
+    pub const DIRECT_DRIVER_LOADING_LIST_LUNARG: Self = Self(1_000_459_001);
+}
+impl ExtExtension461Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_461\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension461Fn {}
+unsafe impl Send for ExtExtension461Fn {}
+unsafe impl Sync for ExtExtension461Fn {}
+impl ExtExtension461Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_extension_461'"]
+impl FormatFeatureFlags2 {
+    pub const RESERVED_39_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_extension_461'"]
+impl ImageUsageFlags {
+    pub const RESERVED_23_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
+}
+impl ExtExtension462Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_462\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension462Fn {}
+unsafe impl Send for ExtExtension462Fn {}
+unsafe impl Sync for ExtExtension462Fn {}
+impl ExtExtension462Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtShaderModuleIdentifierFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_module_identifier\0")
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn(
+    device: Device,
+    shader_module: ShaderModule,
+    p_identifier: *mut ShaderModuleIdentifierEXT,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const ShaderModuleCreateInfo,
+    p_identifier: *mut ShaderModuleIdentifierEXT,
+);
+#[derive(Clone)]
+pub struct ExtShaderModuleIdentifierFn {
+    pub get_shader_module_identifier_ext: PFN_vkGetShaderModuleIdentifierEXT,
+    pub get_shader_module_create_info_identifier_ext: PFN_vkGetShaderModuleCreateInfoIdentifierEXT,
+}
+unsafe impl Send for ExtShaderModuleIdentifierFn {}
+unsafe impl Sync for ExtShaderModuleIdentifierFn {}
+impl ExtShaderModuleIdentifierFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            get_shader_module_identifier_ext: unsafe {
+                unsafe extern "system" fn get_shader_module_identifier_ext(
+                    _device: Device,
+                    _shader_module: ShaderModule,
+                    _p_identifier: *mut ShaderModuleIdentifierEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_shader_module_identifier_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetShaderModuleIdentifierEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_shader_module_identifier_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_shader_module_create_info_identifier_ext: unsafe {
+                unsafe extern "system" fn get_shader_module_create_info_identifier_ext(
+                    _device: Device,
+                    _p_create_info: *const ShaderModuleCreateInfo,
+                    _p_identifier: *mut ShaderModuleIdentifierEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_shader_module_create_info_identifier_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetShaderModuleCreateInfoIdentifierEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_shader_module_create_info_identifier_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_EXT_shader_module_identifier'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: Self = Self(1_000_462_000);
+    pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: Self = Self(1_000_462_001);
+    pub const PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: Self = Self(1_000_462_002);
+    pub const SHADER_MODULE_IDENTIFIER_EXT: Self = Self(1_000_462_003);
+}
+impl ExtRasterizationOrderAttachmentAccessFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_rasterization_order_attachment_access\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtRasterizationOrderAttachmentAccessFn {}
+unsafe impl Send for ExtRasterizationOrderAttachmentAccessFn {}
+unsafe impl Sync for ExtRasterizationOrderAttachmentAccessFn {}
+impl ExtRasterizationOrderAttachmentAccessFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"]
+impl PipelineColorBlendStateCreateFlags {
+    pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT: Self = Self(0b1);
+}
+#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"]
+impl PipelineDepthStencilStateCreateFlags {
+    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT: Self = Self(0b1);
+    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT: Self = Self(0b10);
+}
+#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: Self =
+        Self(1_000_342_000);
+}
+#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"]
+impl SubpassDescriptionFlags {
+    pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT: Self = Self(0b1_0000);
+    pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT: Self = Self(0b10_0000);
+    pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT: Self = Self(0b100_0000);
+}
+impl NvOpticalFlowFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_optical_flow\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV,
+    p_format_count: *mut u32,
+    p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateOpticalFlowSessionNV = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const OpticalFlowSessionCreateInfoNV,
+    p_allocator: *const AllocationCallbacks,
+    p_session: *mut OpticalFlowSessionNV,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyOpticalFlowSessionNV = unsafe extern "system" fn(
+    device: Device,
+    session: OpticalFlowSessionNV,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkBindOpticalFlowSessionImageNV = unsafe extern "system" fn(
+    device: Device,
+    session: OpticalFlowSessionNV,
+    binding_point: OpticalFlowSessionBindingPointNV,
+    view: ImageView,
+    layout: ImageLayout,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdOpticalFlowExecuteNV = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    session: OpticalFlowSessionNV,
+    p_execute_info: *const OpticalFlowExecuteInfoNV,
+);
+#[derive(Clone)]
+pub struct NvOpticalFlowFn {
+    pub get_physical_device_optical_flow_image_formats_nv:
+        PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
+    pub create_optical_flow_session_nv: PFN_vkCreateOpticalFlowSessionNV,
+    pub destroy_optical_flow_session_nv: PFN_vkDestroyOpticalFlowSessionNV,
+    pub bind_optical_flow_session_image_nv: PFN_vkBindOpticalFlowSessionImageNV,
+    pub cmd_optical_flow_execute_nv: PFN_vkCmdOpticalFlowExecuteNV,
+}
+unsafe impl Send for NvOpticalFlowFn {}
+unsafe impl Sync for NvOpticalFlowFn {}
+impl NvOpticalFlowFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            get_physical_device_optical_flow_image_formats_nv: unsafe {
+                unsafe extern "system" fn get_physical_device_optical_flow_image_formats_nv(
+                    _physical_device: PhysicalDevice,
+                    _p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV,
+                    _p_format_count: *mut u32,
+                    _p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_optical_flow_image_formats_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceOpticalFlowImageFormatsNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_optical_flow_image_formats_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_optical_flow_session_nv: unsafe {
+                unsafe extern "system" fn create_optical_flow_session_nv(
+                    _device: Device,
+                    _p_create_info: *const OpticalFlowSessionCreateInfoNV,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_session: *mut OpticalFlowSessionNV,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_optical_flow_session_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCreateOpticalFlowSessionNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    create_optical_flow_session_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_optical_flow_session_nv: unsafe {
+                unsafe extern "system" fn destroy_optical_flow_session_nv(
+                    _device: Device,
+                    _session: OpticalFlowSessionNV,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_optical_flow_session_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkDestroyOpticalFlowSessionNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_optical_flow_session_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            bind_optical_flow_session_image_nv: unsafe {
+                unsafe extern "system" fn bind_optical_flow_session_image_nv(
+                    _device: Device,
+                    _session: OpticalFlowSessionNV,
+                    _binding_point: OpticalFlowSessionBindingPointNV,
+                    _view: ImageView,
+                    _layout: ImageLayout,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(bind_optical_flow_session_image_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkBindOpticalFlowSessionImageNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    bind_optical_flow_session_image_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_optical_flow_execute_nv: unsafe {
+                unsafe extern "system" fn cmd_optical_flow_execute_nv(
+                    _command_buffer: CommandBuffer,
+                    _session: OpticalFlowSessionNV,
+                    _p_execute_info: *const OpticalFlowExecuteInfoNV,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_optical_flow_execute_nv)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdOpticalFlowExecuteNV\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_optical_flow_execute_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_NV_optical_flow'"]
+impl AccessFlags2 {
+    pub const OPTICAL_FLOW_READ_NV: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const OPTICAL_FLOW_WRITE_NV: Self =
+        Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_NV_optical_flow'"]
+impl Format {
+    pub const R16G16_S10_5_NV: Self = Self(1_000_464_000);
+}
+#[doc = "Generated from 'VK_NV_optical_flow'"]
+impl FormatFeatureFlags2 {
+    pub const OPTICAL_FLOW_IMAGE_NV: Self =
+        Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const OPTICAL_FLOW_VECTOR_NV: Self =
+        Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const OPTICAL_FLOW_COST_NV: Self =
+        Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_NV_optical_flow'"]
+impl ObjectType {
+    pub const OPTICAL_FLOW_SESSION_NV: Self = Self(1_000_464_000);
+}
+#[doc = "Generated from 'VK_NV_optical_flow'"]
+impl PipelineStageFlags2 {
+    pub const OPTICAL_FLOW_NV: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_NV_optical_flow'"]
+impl QueueFlags {
+    pub const OPTICAL_FLOW_NV: Self = Self(0b1_0000_0000);
+}
+#[doc = "Generated from 'VK_NV_optical_flow'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: Self = Self(1_000_464_000);
+    pub const PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: Self = Self(1_000_464_001);
+    pub const OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: Self = Self(1_000_464_002);
+    pub const OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: Self = Self(1_000_464_003);
+    pub const OPTICAL_FLOW_SESSION_CREATE_INFO_NV: Self = Self(1_000_464_004);
+    pub const OPTICAL_FLOW_EXECUTE_INFO_NV: Self = Self(1_000_464_005);
+    pub const OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: Self = Self(1_000_464_010);
+}
+impl ExtLegacyDitheringFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_legacy_dithering\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtLegacyDitheringFn {}
+unsafe impl Send for ExtLegacyDitheringFn {}
+unsafe impl Sync for ExtLegacyDitheringFn {}
+impl ExtLegacyDitheringFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_legacy_dithering'"]
+impl RenderingFlags {
+    pub const ENABLE_LEGACY_DITHERING_EXT: Self = Self(0b1000);
+}
+#[doc = "Generated from 'VK_EXT_legacy_dithering'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: Self = Self(1_000_465_000);
+}
+#[doc = "Generated from 'VK_EXT_legacy_dithering'"]
+impl SubpassDescriptionFlags {
+    pub const ENABLE_LEGACY_DITHERING_EXT: Self = Self(0b1000_0000);
+}
+impl ExtPipelineProtectedAccessFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_protected_access\0")
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtPipelineProtectedAccessFn {}
+unsafe impl Send for ExtPipelineProtectedAccessFn {}
+unsafe impl Sync for ExtPipelineProtectedAccessFn {}
+impl ExtPipelineProtectedAccessFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"]
+impl PipelineCreateFlags {
+    pub const NO_PROTECTED_ACCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
+    pub const PROTECTED_ACCESS_ONLY_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: Self = Self(1_000_466_000);
+}
+impl ExtExtension468Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_468\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension468Fn {}
+unsafe impl Send for ExtExtension468Fn {}
+unsafe impl Sync for ExtExtension468Fn {}
+impl ExtExtension468Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AndroidExtension469Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_extension_469\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AndroidExtension469Fn {}
+unsafe impl Send for AndroidExtension469Fn {}
+unsafe impl Sync for AndroidExtension469Fn {}
+impl AndroidExtension469Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_ANDROID_extension_469'"]
+impl ResolveModeFlags {
+    pub const EXTENSION_469_FLAG_0: Self = Self(0b1_0000);
+}
+impl AmdExtension470Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_470\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension470Fn {}
+unsafe impl Send for AmdExtension470Fn {}
+unsafe impl Sync for AmdExtension470Fn {}
+impl AmdExtension470Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AmdExtension471Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_471\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension471Fn {}
+unsafe impl Send for AmdExtension471Fn {}
+unsafe impl Sync for AmdExtension471Fn {}
+impl AmdExtension471Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AmdExtension472Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_472\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension472Fn {}
+unsafe impl Send for AmdExtension472Fn {}
+unsafe impl Sync for AmdExtension472Fn {}
+impl AmdExtension472Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AmdExtension473Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_473\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension473Fn {}
+unsafe impl Send for AmdExtension473Fn {}
+unsafe impl Sync for AmdExtension473Fn {}
+impl AmdExtension473Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AmdExtension474Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_474\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension474Fn {}
+unsafe impl Send for AmdExtension474Fn {}
+unsafe impl Sync for AmdExtension474Fn {}
+impl AmdExtension474Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AmdExtension475Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_475\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension475Fn {}
+unsafe impl Send for AmdExtension475Fn {}
+unsafe impl Sync for AmdExtension475Fn {}
+impl AmdExtension475Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AmdExtension476Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_476\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension476Fn {}
+unsafe impl Send for AmdExtension476Fn {}
+unsafe impl Sync for AmdExtension476Fn {}
+impl AmdExtension476Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AmdExtension477Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_477\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension477Fn {}
+unsafe impl Send for AmdExtension477Fn {}
+unsafe impl Sync for AmdExtension477Fn {}
+impl AmdExtension477Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AmdExtension478Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_478\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension478Fn {}
+unsafe impl Send for AmdExtension478Fn {}
+unsafe impl Sync for AmdExtension478Fn {}
+impl AmdExtension478Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl AmdExtension479Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_479\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct AmdExtension479Fn {}
+unsafe impl Send for AmdExtension479Fn {}
+unsafe impl Sync for AmdExtension479Fn {}
+impl AmdExtension479Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension480Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_480\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension480Fn {}
+unsafe impl Send for ExtExtension480Fn {}
+unsafe impl Sync for ExtExtension480Fn {}
+impl ExtExtension480Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension481Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_481\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension481Fn {}
+unsafe impl Send for ExtExtension481Fn {}
+unsafe impl Sync for ExtExtension481Fn {}
+impl ExtExtension481Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl KhrRayTracingPositionFetchFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_position_fetch\0")
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct KhrRayTracingPositionFetchFn {}
+unsafe impl Send for KhrRayTracingPositionFetchFn {}
+unsafe impl Sync for KhrRayTracingPositionFetchFn {}
+impl KhrRayTracingPositionFetchFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_KHR_ray_tracing_position_fetch'"]
+impl BuildAccelerationStructureFlagsKHR {
+    pub const ALLOW_DATA_ACCESS: Self = Self(0b1000_0000_0000);
+}
+#[doc = "Generated from 'VK_KHR_ray_tracing_position_fetch'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: Self = Self(1_000_481_000);
+}
+impl ExtShaderObjectFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_object\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateShadersEXT = unsafe extern "system" fn(
+    device: Device,
+    create_info_count: u32,
+    p_create_infos: *const ShaderCreateInfoEXT,
+    p_allocator: *const AllocationCallbacks,
+    p_shaders: *mut ShaderEXT,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyShaderEXT = unsafe extern "system" fn(
+    device: Device,
+    shader: ShaderEXT,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetShaderBinaryDataEXT = unsafe extern "system" fn(
+    device: Device,
+    shader: ShaderEXT,
+    p_data_size: *mut usize,
+    p_data: *mut c_void,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBindShadersEXT = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    stage_count: u32,
+    p_stages: *const ShaderStageFlags,
+    p_shaders: *const ShaderEXT,
+);
+#[derive(Clone)]
+pub struct ExtShaderObjectFn {
+    pub create_shaders_ext: PFN_vkCreateShadersEXT,
+    pub destroy_shader_ext: PFN_vkDestroyShaderEXT,
+    pub get_shader_binary_data_ext: PFN_vkGetShaderBinaryDataEXT,
+    pub cmd_bind_shaders_ext: PFN_vkCmdBindShadersEXT,
+    pub cmd_set_cull_mode_ext: crate::vk::PFN_vkCmdSetCullMode,
+    pub cmd_set_front_face_ext: crate::vk::PFN_vkCmdSetFrontFace,
+    pub cmd_set_primitive_topology_ext: crate::vk::PFN_vkCmdSetPrimitiveTopology,
+    pub cmd_set_viewport_with_count_ext: crate::vk::PFN_vkCmdSetViewportWithCount,
+    pub cmd_set_scissor_with_count_ext: crate::vk::PFN_vkCmdSetScissorWithCount,
+    pub cmd_bind_vertex_buffers2_ext: crate::vk::PFN_vkCmdBindVertexBuffers2,
+    pub cmd_set_depth_test_enable_ext: crate::vk::PFN_vkCmdSetDepthTestEnable,
+    pub cmd_set_depth_write_enable_ext: crate::vk::PFN_vkCmdSetDepthWriteEnable,
+    pub cmd_set_depth_compare_op_ext: crate::vk::PFN_vkCmdSetDepthCompareOp,
+    pub cmd_set_depth_bounds_test_enable_ext: crate::vk::PFN_vkCmdSetDepthBoundsTestEnable,
+    pub cmd_set_stencil_test_enable_ext: crate::vk::PFN_vkCmdSetStencilTestEnable,
+    pub cmd_set_stencil_op_ext: crate::vk::PFN_vkCmdSetStencilOp,
+    pub cmd_set_vertex_input_ext: crate::vk::PFN_vkCmdSetVertexInputEXT,
+    pub cmd_set_patch_control_points_ext: crate::vk::PFN_vkCmdSetPatchControlPointsEXT,
+    pub cmd_set_rasterizer_discard_enable_ext: crate::vk::PFN_vkCmdSetRasterizerDiscardEnable,
+    pub cmd_set_depth_bias_enable_ext: crate::vk::PFN_vkCmdSetDepthBiasEnable,
+    pub cmd_set_logic_op_ext: crate::vk::PFN_vkCmdSetLogicOpEXT,
+    pub cmd_set_primitive_restart_enable_ext: crate::vk::PFN_vkCmdSetPrimitiveRestartEnable,
+    pub cmd_set_tessellation_domain_origin_ext: crate::vk::PFN_vkCmdSetTessellationDomainOriginEXT,
+    pub cmd_set_depth_clamp_enable_ext: crate::vk::PFN_vkCmdSetDepthClampEnableEXT,
+    pub cmd_set_polygon_mode_ext: crate::vk::PFN_vkCmdSetPolygonModeEXT,
+    pub cmd_set_rasterization_samples_ext: crate::vk::PFN_vkCmdSetRasterizationSamplesEXT,
+    pub cmd_set_sample_mask_ext: crate::vk::PFN_vkCmdSetSampleMaskEXT,
+    pub cmd_set_alpha_to_coverage_enable_ext: crate::vk::PFN_vkCmdSetAlphaToCoverageEnableEXT,
+    pub cmd_set_alpha_to_one_enable_ext: crate::vk::PFN_vkCmdSetAlphaToOneEnableEXT,
+    pub cmd_set_logic_op_enable_ext: crate::vk::PFN_vkCmdSetLogicOpEnableEXT,
+    pub cmd_set_color_blend_enable_ext: crate::vk::PFN_vkCmdSetColorBlendEnableEXT,
+    pub cmd_set_color_blend_equation_ext: crate::vk::PFN_vkCmdSetColorBlendEquationEXT,
+    pub cmd_set_color_write_mask_ext: crate::vk::PFN_vkCmdSetColorWriteMaskEXT,
+    pub cmd_set_rasterization_stream_ext: crate::vk::PFN_vkCmdSetRasterizationStreamEXT,
+    pub cmd_set_conservative_rasterization_mode_ext:
+        crate::vk::PFN_vkCmdSetConservativeRasterizationModeEXT,
+    pub cmd_set_extra_primitive_overestimation_size_ext:
+        crate::vk::PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
+    pub cmd_set_depth_clip_enable_ext: crate::vk::PFN_vkCmdSetDepthClipEnableEXT,
+    pub cmd_set_sample_locations_enable_ext: crate::vk::PFN_vkCmdSetSampleLocationsEnableEXT,
+    pub cmd_set_color_blend_advanced_ext: crate::vk::PFN_vkCmdSetColorBlendAdvancedEXT,
+    pub cmd_set_provoking_vertex_mode_ext: crate::vk::PFN_vkCmdSetProvokingVertexModeEXT,
+    pub cmd_set_line_rasterization_mode_ext: crate::vk::PFN_vkCmdSetLineRasterizationModeEXT,
+    pub cmd_set_line_stipple_enable_ext: crate::vk::PFN_vkCmdSetLineStippleEnableEXT,
+    pub cmd_set_depth_clip_negative_one_to_one_ext:
+        crate::vk::PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
+    pub cmd_set_viewport_w_scaling_enable_nv: crate::vk::PFN_vkCmdSetViewportWScalingEnableNV,
+    pub cmd_set_viewport_swizzle_nv: crate::vk::PFN_vkCmdSetViewportSwizzleNV,
+    pub cmd_set_coverage_to_color_enable_nv: crate::vk::PFN_vkCmdSetCoverageToColorEnableNV,
+    pub cmd_set_coverage_to_color_location_nv: crate::vk::PFN_vkCmdSetCoverageToColorLocationNV,
+    pub cmd_set_coverage_modulation_mode_nv: crate::vk::PFN_vkCmdSetCoverageModulationModeNV,
+    pub cmd_set_coverage_modulation_table_enable_nv:
+        crate::vk::PFN_vkCmdSetCoverageModulationTableEnableNV,
+    pub cmd_set_coverage_modulation_table_nv: crate::vk::PFN_vkCmdSetCoverageModulationTableNV,
+    pub cmd_set_shading_rate_image_enable_nv: crate::vk::PFN_vkCmdSetShadingRateImageEnableNV,
+    pub cmd_set_representative_fragment_test_enable_nv:
+        crate::vk::PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
+    pub cmd_set_coverage_reduction_mode_nv: crate::vk::PFN_vkCmdSetCoverageReductionModeNV,
+}
+unsafe impl Send for ExtShaderObjectFn {}
+unsafe impl Sync for ExtShaderObjectFn {}
+impl ExtShaderObjectFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            create_shaders_ext: unsafe {
+                unsafe extern "system" fn create_shaders_ext(
+                    _device: Device,
+                    _create_info_count: u32,
+                    _p_create_infos: *const ShaderCreateInfoEXT,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_shaders: *mut ShaderEXT,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_shaders_ext)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateShadersEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_shaders_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_shader_ext: unsafe {
+                unsafe extern "system" fn destroy_shader_ext(
+                    _device: Device,
+                    _shader: ShaderEXT,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_shader_ext)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_shader_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_shader_binary_data_ext: unsafe {
+                unsafe extern "system" fn get_shader_binary_data_ext(
+                    _device: Device,
+                    _shader: ShaderEXT,
+                    _p_data_size: *mut usize,
+                    _p_data: *mut c_void,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_shader_binary_data_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetShaderBinaryDataEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_shader_binary_data_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_shaders_ext: unsafe {
+                unsafe extern "system" fn cmd_bind_shaders_ext(
+                    _command_buffer: CommandBuffer,
+                    _stage_count: u32,
+                    _p_stages: *const ShaderStageFlags,
+                    _p_shaders: *const ShaderEXT,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_bind_shaders_ext)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindShadersEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_shaders_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_cull_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_cull_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _cull_mode: CullModeFlags,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_cull_mode_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_cull_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_front_face_ext: unsafe {
+                unsafe extern "system" fn cmd_set_front_face_ext(
+                    _command_buffer: CommandBuffer,
+                    _front_face: FrontFace,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_front_face_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_front_face_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_primitive_topology_ext: unsafe {
+                unsafe extern "system" fn cmd_set_primitive_topology_ext(
+                    _command_buffer: CommandBuffer,
+                    _primitive_topology: PrimitiveTopology,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_primitive_topology_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetPrimitiveTopologyEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_primitive_topology_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_viewport_with_count_ext: unsafe {
+                unsafe extern "system" fn cmd_set_viewport_with_count_ext(
+                    _command_buffer: CommandBuffer,
+                    _viewport_count: u32,
+                    _p_viewports: *const Viewport,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_viewport_with_count_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetViewportWithCountEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_viewport_with_count_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_scissor_with_count_ext: unsafe {
+                unsafe extern "system" fn cmd_set_scissor_with_count_ext(
+                    _command_buffer: CommandBuffer,
+                    _scissor_count: u32,
+                    _p_scissors: *const Rect2D,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_scissor_with_count_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetScissorWithCountEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_scissor_with_count_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_vertex_buffers2_ext: unsafe {
+                unsafe extern "system" fn cmd_bind_vertex_buffers2_ext(
+                    _command_buffer: CommandBuffer,
+                    _first_binding: u32,
+                    _binding_count: u32,
+                    _p_buffers: *const Buffer,
+                    _p_offsets: *const DeviceSize,
+                    _p_sizes: *const DeviceSize,
+                    _p_strides: *const DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_bind_vertex_buffers2_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdBindVertexBuffers2EXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_vertex_buffers2_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_test_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_test_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _depth_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_test_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthTestEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_test_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_write_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_write_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _depth_write_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_write_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthWriteEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_write_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_compare_op_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_compare_op_ext(
+                    _command_buffer: CommandBuffer,
+                    _depth_compare_op: CompareOp,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_compare_op_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_compare_op_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_bounds_test_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _depth_bounds_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_bounds_test_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthBoundsTestEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_bounds_test_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_stencil_test_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_stencil_test_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _stencil_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_stencil_test_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetStencilTestEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_stencil_test_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_stencil_op_ext: unsafe {
+                unsafe extern "system" fn cmd_set_stencil_op_ext(
+                    _command_buffer: CommandBuffer,
+                    _face_mask: StencilFaceFlags,
+                    _fail_op: StencilOp,
+                    _pass_op: StencilOp,
+                    _depth_fail_op: StencilOp,
+                    _compare_op: CompareOp,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_stencil_op_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_stencil_op_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_vertex_input_ext: unsafe {
+                unsafe extern "system" fn cmd_set_vertex_input_ext(
+                    _command_buffer: CommandBuffer,
+                    _vertex_binding_description_count: u32,
+                    _p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT,
+                    _vertex_attribute_description_count: u32,
+                    _p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_vertex_input_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_vertex_input_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_patch_control_points_ext: unsafe {
+                unsafe extern "system" fn cmd_set_patch_control_points_ext(
+                    _command_buffer: CommandBuffer,
+                    _patch_control_points: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_patch_control_points_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetPatchControlPointsEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_patch_control_points_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_rasterizer_discard_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _rasterizer_discard_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_rasterizer_discard_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetRasterizerDiscardEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_rasterizer_discard_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_bias_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_bias_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _depth_bias_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_bias_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthBiasEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_bias_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_logic_op_ext: unsafe {
+                unsafe extern "system" fn cmd_set_logic_op_ext(
+                    _command_buffer: CommandBuffer,
+                    _logic_op: LogicOp,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_logic_op_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_primitive_restart_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_primitive_restart_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _primitive_restart_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_primitive_restart_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetPrimitiveRestartEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_primitive_restart_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_tessellation_domain_origin_ext: unsafe {
+                unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext(
+                    _command_buffer: CommandBuffer,
+                    _domain_origin: TessellationDomainOrigin,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_tessellation_domain_origin_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetTessellationDomainOriginEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_tessellation_domain_origin_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_clamp_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_clamp_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _depth_clamp_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_clamp_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthClampEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_clamp_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_polygon_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_polygon_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _polygon_mode: PolygonMode,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_polygon_mode_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_polygon_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_rasterization_samples_ext: unsafe {
+                unsafe extern "system" fn cmd_set_rasterization_samples_ext(
+                    _command_buffer: CommandBuffer,
+                    _rasterization_samples: SampleCountFlags,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_rasterization_samples_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetRasterizationSamplesEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_rasterization_samples_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_sample_mask_ext: unsafe {
+                unsafe extern "system" fn cmd_set_sample_mask_ext(
+                    _command_buffer: CommandBuffer,
+                    _samples: SampleCountFlags,
+                    _p_sample_mask: *const SampleMask,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_sample_mask_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_sample_mask_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_alpha_to_coverage_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _alpha_to_coverage_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_alpha_to_coverage_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetAlphaToCoverageEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_alpha_to_coverage_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_alpha_to_one_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _alpha_to_one_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_alpha_to_one_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetAlphaToOneEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_alpha_to_one_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_logic_op_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_logic_op_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _logic_op_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_logic_op_enable_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_logic_op_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_color_blend_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_color_blend_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _first_attachment: u32,
+                    _attachment_count: u32,
+                    _p_color_blend_enables: *const Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_color_blend_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetColorBlendEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_color_blend_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_color_blend_equation_ext: unsafe {
+                unsafe extern "system" fn cmd_set_color_blend_equation_ext(
+                    _command_buffer: CommandBuffer,
+                    _first_attachment: u32,
+                    _attachment_count: u32,
+                    _p_color_blend_equations: *const ColorBlendEquationEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_color_blend_equation_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetColorBlendEquationEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_color_blend_equation_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_color_write_mask_ext: unsafe {
+                unsafe extern "system" fn cmd_set_color_write_mask_ext(
+                    _command_buffer: CommandBuffer,
+                    _first_attachment: u32,
+                    _attachment_count: u32,
+                    _p_color_write_masks: *const ColorComponentFlags,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_color_write_mask_ext)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_color_write_mask_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_rasterization_stream_ext: unsafe {
+                unsafe extern "system" fn cmd_set_rasterization_stream_ext(
+                    _command_buffer: CommandBuffer,
+                    _rasterization_stream: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_rasterization_stream_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetRasterizationStreamEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_rasterization_stream_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_conservative_rasterization_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _conservative_rasterization_mode: ConservativeRasterizationModeEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_conservative_rasterization_mode_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetConservativeRasterizationModeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_conservative_rasterization_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_extra_primitive_overestimation_size_ext: unsafe {
+                unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext(
+                    _command_buffer: CommandBuffer,
+                    _extra_primitive_overestimation_size: f32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_extra_primitive_overestimation_size_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_extra_primitive_overestimation_size_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_clip_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_clip_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _depth_clip_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_clip_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthClipEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_clip_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_sample_locations_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_sample_locations_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _sample_locations_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_sample_locations_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetSampleLocationsEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_sample_locations_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_color_blend_advanced_ext: unsafe {
+                unsafe extern "system" fn cmd_set_color_blend_advanced_ext(
+                    _command_buffer: CommandBuffer,
+                    _first_attachment: u32,
+                    _attachment_count: u32,
+                    _p_color_blend_advanced: *const ColorBlendAdvancedEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_color_blend_advanced_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetColorBlendAdvancedEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_color_blend_advanced_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_provoking_vertex_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _provoking_vertex_mode: ProvokingVertexModeEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_provoking_vertex_mode_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetProvokingVertexModeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_provoking_vertex_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_line_rasterization_mode_ext: unsafe {
+                unsafe extern "system" fn cmd_set_line_rasterization_mode_ext(
+                    _command_buffer: CommandBuffer,
+                    _line_rasterization_mode: LineRasterizationModeEXT,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_line_rasterization_mode_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetLineRasterizationModeEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_line_rasterization_mode_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_line_stipple_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_line_stipple_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _stippled_line_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_line_stipple_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetLineStippleEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_line_stipple_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_clip_negative_one_to_one_ext: unsafe {
+                unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext(
+                    _command_buffer: CommandBuffer,
+                    _negative_one_to_one: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_clip_negative_one_to_one_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthClipNegativeOneToOneEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_clip_negative_one_to_one_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_viewport_w_scaling_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _viewport_w_scaling_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_viewport_w_scaling_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetViewportWScalingEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_viewport_w_scaling_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_viewport_swizzle_nv: unsafe {
+                unsafe extern "system" fn cmd_set_viewport_swizzle_nv(
+                    _command_buffer: CommandBuffer,
+                    _first_viewport: u32,
+                    _viewport_count: u32,
+                    _p_viewport_swizzles: *const ViewportSwizzleNV,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_viewport_swizzle_nv)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_viewport_swizzle_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_to_color_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_to_color_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_to_color_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageToColorEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_to_color_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_to_color_location_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_to_color_location_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_to_color_location: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_to_color_location_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageToColorLocationNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_to_color_location_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_modulation_mode_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_modulation_mode: CoverageModulationModeNV,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_modulation_mode_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageModulationModeNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_modulation_mode_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_modulation_table_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_modulation_table_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_modulation_table_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageModulationTableEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_modulation_table_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_modulation_table_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_modulation_table_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_modulation_table_count: u32,
+                    _p_coverage_modulation_table: *const f32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_modulation_table_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageModulationTableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_modulation_table_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_shading_rate_image_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _shading_rate_image_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_shading_rate_image_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetShadingRateImageEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_shading_rate_image_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_representative_fragment_test_enable_nv: unsafe {
+                unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv(
+                    _command_buffer: CommandBuffer,
+                    _representative_fragment_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_representative_fragment_test_enable_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetRepresentativeFragmentTestEnableNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_representative_fragment_test_enable_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_coverage_reduction_mode_nv: unsafe {
+                unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv(
+                    _command_buffer: CommandBuffer,
+                    _coverage_reduction_mode: CoverageReductionModeNV,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_coverage_reduction_mode_nv)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetCoverageReductionModeNV\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_coverage_reduction_mode_nv
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_EXT_shader_object'"]
+impl ObjectType {
+    pub const SHADER_EXT: Self = Self(1_000_482_000);
+}
+#[doc = "Generated from 'VK_EXT_shader_object'"]
+impl Result {
+    pub const ERROR_INCOMPATIBLE_SHADER_BINARY_EXT: Self = Self(1_000_482_000);
+}
+#[doc = "Generated from 'VK_EXT_shader_object'"]
+impl ShaderCreateFlagsEXT {
+    pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(0b10);
+    pub const REQUIRE_FULL_SUBGROUPS: Self = Self(0b100);
+    pub const NO_TASK_SHADER: Self = Self(0b1000);
+    pub const DISPATCH_BASE: Self = Self(0b1_0000);
+    pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(0b10_0000);
+    pub const FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self(0b100_0000);
+}
+#[doc = "Generated from 'VK_EXT_shader_object'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: Self = Self(1_000_482_000);
+    pub const PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: Self = Self(1_000_482_001);
+    pub const SHADER_CREATE_INFO_EXT: Self = Self(1_000_482_002);
+    pub const SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self =
+        Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
+}
+impl ExtExtension484Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_484\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension484Fn {}
+unsafe impl Send for ExtExtension484Fn {}
+unsafe impl Sync for ExtExtension484Fn {}
+impl ExtExtension484Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QcomTilePropertiesFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_tile_properties\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetFramebufferTilePropertiesQCOM = unsafe extern "system" fn(
+    device: Device,
+    framebuffer: Framebuffer,
+    p_properties_count: *mut u32,
+    p_properties: *mut TilePropertiesQCOM,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDynamicRenderingTilePropertiesQCOM = unsafe extern "system" fn(
+    device: Device,
+    p_rendering_info: *const RenderingInfo,
+    p_properties: *mut TilePropertiesQCOM,
+) -> Result;
+#[derive(Clone)]
+pub struct QcomTilePropertiesFn {
+    pub get_framebuffer_tile_properties_qcom: PFN_vkGetFramebufferTilePropertiesQCOM,
+    pub get_dynamic_rendering_tile_properties_qcom: PFN_vkGetDynamicRenderingTilePropertiesQCOM,
+}
+unsafe impl Send for QcomTilePropertiesFn {}
+unsafe impl Sync for QcomTilePropertiesFn {}
+impl QcomTilePropertiesFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            get_framebuffer_tile_properties_qcom: unsafe {
+                unsafe extern "system" fn get_framebuffer_tile_properties_qcom(
+                    _device: Device,
+                    _framebuffer: Framebuffer,
+                    _p_properties_count: *mut u32,
+                    _p_properties: *mut TilePropertiesQCOM,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_framebuffer_tile_properties_qcom)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetFramebufferTilePropertiesQCOM\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_framebuffer_tile_properties_qcom
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_dynamic_rendering_tile_properties_qcom: unsafe {
+                unsafe extern "system" fn get_dynamic_rendering_tile_properties_qcom(
+                    _device: Device,
+                    _p_rendering_info: *const RenderingInfo,
+                    _p_properties: *mut TilePropertiesQCOM,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_dynamic_rendering_tile_properties_qcom)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDynamicRenderingTilePropertiesQCOM\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_dynamic_rendering_tile_properties_qcom
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_QCOM_tile_properties'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: Self = Self(1_000_484_000);
+    pub const TILE_PROPERTIES_QCOM: Self = Self(1_000_484_001);
+}
+impl SecAmigoProfilingFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_amigo_profiling\0") }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct SecAmigoProfilingFn {}
+unsafe impl Send for SecAmigoProfilingFn {}
+unsafe impl Sync for SecAmigoProfilingFn {}
+impl SecAmigoProfilingFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_SEC_amigo_profiling'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: Self = Self(1_000_485_000);
+    pub const AMIGO_PROFILING_SUBMIT_INFO_SEC: Self = Self(1_000_485_001);
+}
+impl ExtExtension487Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_487\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension487Fn {}
+unsafe impl Send for ExtExtension487Fn {}
+unsafe impl Sync for ExtExtension487Fn {}
+impl ExtExtension487Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension488Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_488\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension488Fn {}
+unsafe impl Send for ExtExtension488Fn {}
+unsafe impl Sync for ExtExtension488Fn {}
+impl ExtExtension488Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QcomMultiviewPerViewViewportsFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_QCOM_multiview_per_view_viewports\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct QcomMultiviewPerViewViewportsFn {}
+unsafe impl Send for QcomMultiviewPerViewViewportsFn {}
+unsafe impl Sync for QcomMultiviewPerViewViewportsFn {}
+impl QcomMultiviewPerViewViewportsFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_QCOM_multiview_per_view_viewports'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: Self =
+        Self(1_000_488_000);
+}
+impl NvRayTracingInvocationReorderFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_NV_ray_tracing_invocation_reorder\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct NvRayTracingInvocationReorderFn {}
+unsafe impl Send for NvRayTracingInvocationReorderFn {}
+unsafe impl Sync for NvRayTracingInvocationReorderFn {}
+impl NvRayTracingInvocationReorderFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_NV_ray_tracing_invocation_reorder'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: Self =
+        Self(1_000_490_000);
+    pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: Self =
+        Self(1_000_490_001);
+}
+impl NvExtension492Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_492\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension492Fn {}
+unsafe impl Send for NvExtension492Fn {}
+unsafe impl Sync for NvExtension492Fn {}
+impl NvExtension492Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl NvExtension493Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_493\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension493Fn {}
+unsafe impl Send for NvExtension493Fn {}
+unsafe impl Sync for NvExtension493Fn {}
+impl NvExtension493Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl NvExtension494Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_494\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension494Fn {}
+unsafe impl Send for NvExtension494Fn {}
+unsafe impl Sync for NvExtension494Fn {}
+impl NvExtension494Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtMutableDescriptorTypeFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_mutable_descriptor_type\0")
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtMutableDescriptorTypeFn {}
+unsafe impl Send for ExtMutableDescriptorTypeFn {}
+unsafe impl Sync for ExtMutableDescriptorTypeFn {}
+impl ExtMutableDescriptorTypeFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"]
+impl DescriptorPoolCreateFlags {
+    pub const HOST_ONLY_EXT: Self = Self(0b100);
+}
+#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"]
+impl DescriptorSetLayoutCreateFlags {
+    pub const HOST_ONLY_POOL_EXT: Self = Self(0b100);
+}
+#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"]
+impl DescriptorType {
+    pub const MUTABLE_EXT: Self = Self(1_000_351_000);
+}
+#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: Self = Self(1_000_351_000);
+    pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: Self = Self(1_000_351_002);
+}
+impl ExtExtension496Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_496\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension496Fn {}
+unsafe impl Send for ExtExtension496Fn {}
+unsafe impl Sync for ExtExtension496Fn {}
+impl ExtExtension496Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension497Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_497\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension497Fn {}
+unsafe impl Send for ExtExtension497Fn {}
+unsafe impl Sync for ExtExtension497Fn {}
+impl ExtExtension497Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ArmShaderCoreBuiltinsFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_shader_core_builtins\0") }
+    }
+    pub const SPEC_VERSION: u32 = 2u32;
+}
+#[derive(Clone)]
+pub struct ArmShaderCoreBuiltinsFn {}
+unsafe impl Send for ArmShaderCoreBuiltinsFn {}
+unsafe impl Sync for ArmShaderCoreBuiltinsFn {}
+impl ArmShaderCoreBuiltinsFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_ARM_shader_core_builtins'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: Self = Self(1_000_497_000);
+    pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: Self = Self(1_000_497_001);
+}
+impl ExtPipelineLibraryGroupHandlesFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_pipeline_library_group_handles\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtPipelineLibraryGroupHandlesFn {}
+unsafe impl Send for ExtPipelineLibraryGroupHandlesFn {}
+unsafe impl Sync for ExtPipelineLibraryGroupHandlesFn {}
+impl ExtPipelineLibraryGroupHandlesFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_pipeline_library_group_handles'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: Self =
+        Self(1_000_498_000);
+}
+impl ExtDynamicRenderingUnusedAttachmentsFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_dynamic_rendering_unused_attachments\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct ExtDynamicRenderingUnusedAttachmentsFn {}
+unsafe impl Send for ExtDynamicRenderingUnusedAttachmentsFn {}
+unsafe impl Sync for ExtDynamicRenderingUnusedAttachmentsFn {}
+impl ExtDynamicRenderingUnusedAttachmentsFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_dynamic_rendering_unused_attachments'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: Self =
+        Self(1_000_499_000);
+}
+impl ExtExtension501Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_501\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension501Fn {}
+unsafe impl Send for ExtExtension501Fn {}
+unsafe impl Sync for ExtExtension501Fn {}
+impl ExtExtension501Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension502Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_502\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension502Fn {}
+unsafe impl Send for ExtExtension502Fn {}
+unsafe impl Sync for ExtExtension502Fn {}
+impl ExtExtension502Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension503Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_503\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension503Fn {}
+unsafe impl Send for ExtExtension503Fn {}
+unsafe impl Sync for ExtExtension503Fn {}
+impl ExtExtension503Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl NvExtension504Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_504\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension504Fn {}
+unsafe impl Send for NvExtension504Fn {}
+unsafe impl Sync for NvExtension504Fn {}
+impl NvExtension504Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension505Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_505\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension505Fn {}
+unsafe impl Send for ExtExtension505Fn {}
+unsafe impl Sync for ExtExtension505Fn {}
+impl ExtExtension505Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl NvExtension506Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_506\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct NvExtension506Fn {}
+unsafe impl Send for NvExtension506Fn {}
+unsafe impl Sync for NvExtension506Fn {}
+impl NvExtension506Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl KhrExtension507Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_507\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct KhrExtension507Fn {}
+unsafe impl Send for KhrExtension507Fn {}
+unsafe impl Sync for KhrExtension507Fn {}
+impl KhrExtension507Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension508Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_508\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension508Fn {}
+unsafe impl Send for ExtExtension508Fn {}
+unsafe impl Sync for ExtExtension508Fn {}
+impl ExtExtension508Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_extension_508'"]
+impl AccessFlags2 {
+    pub const RESERVED_47_EXT: Self =
+        Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+    pub const RESERVED_48_EXT: Self =
+        Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_extension_508'"]
+impl PipelineStageFlags2 {
+    pub const RESERVED_42_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
+}
+#[doc = "Generated from 'VK_EXT_extension_508'"]
+impl QueueFlags {
+    pub const RESERVED_10_EXT: Self = Self(0b100_0000_0000);
+}
+impl ExtExtension509Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_509\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension509Fn {}
+unsafe impl Send for ExtExtension509Fn {}
+unsafe impl Sync for ExtExtension509Fn {}
+impl ExtExtension509Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl MesaExtension510Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_510\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct MesaExtension510Fn {}
+unsafe impl Send for MesaExtension510Fn {}
+unsafe impl Sync for MesaExtension510Fn {}
+impl MesaExtension510Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QcomMultiviewPerViewRenderAreasFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_QCOM_multiview_per_view_render_areas\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[derive(Clone)]
+pub struct QcomMultiviewPerViewRenderAreasFn {}
+unsafe impl Send for QcomMultiviewPerViewRenderAreasFn {}
+unsafe impl Sync for QcomMultiviewPerViewRenderAreasFn {}
+impl QcomMultiviewPerViewRenderAreasFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_QCOM_multiview_per_view_render_areas'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: Self =
+        Self(1_000_510_000);
+    pub const MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: Self =
+        Self(1_000_510_001);
+}
+impl ExtExtension512Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_512\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension512Fn {}
+unsafe impl Send for ExtExtension512Fn {}
+unsafe impl Sync for ExtExtension512Fn {}
+impl ExtExtension512Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl KhrExtension513Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_513\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct KhrExtension513Fn {}
+unsafe impl Send for KhrExtension513Fn {}
+unsafe impl Sync for KhrExtension513Fn {}
+impl KhrExtension513Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl KhrExtension514Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_514\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct KhrExtension514Fn {}
+unsafe impl Send for KhrExtension514Fn {}
+unsafe impl Sync for KhrExtension514Fn {}
+impl KhrExtension514Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl KhrExtension515Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_515\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct KhrExtension515Fn {}
+unsafe impl Send for KhrExtension515Fn {}
+unsafe impl Sync for KhrExtension515Fn {}
+impl KhrExtension515Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl KhrExtension516Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_516\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct KhrExtension516Fn {}
+unsafe impl Send for KhrExtension516Fn {}
+unsafe impl Sync for KhrExtension516Fn {}
+impl KhrExtension516Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_KHR_extension_516'"]
+impl BufferCreateFlags {
+    pub const RESERVED_6_KHR: Self = Self(0b100_0000);
+}
+#[doc = "Generated from 'VK_KHR_extension_516'"]
+impl ImageCreateFlags {
+    pub const RESERVED_20_KHR: Self = Self(0b1_0000_0000_0000_0000_0000);
+}
+impl ExtExtension517Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_517\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension517Fn {}
+unsafe impl Send for ExtExtension517Fn {}
+unsafe impl Sync for ExtExtension517Fn {}
+impl ExtExtension517Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_EXT_extension_517'"]
+impl DescriptorSetLayoutCreateFlags {
+    pub const RESERVED_6_EXT: Self = Self(0b100_0000);
+}
+impl MesaExtension518Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_518\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct MesaExtension518Fn {}
+unsafe impl Send for MesaExtension518Fn {}
+unsafe impl Sync for MesaExtension518Fn {}
+impl MesaExtension518Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QcomExtension519Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_519\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct QcomExtension519Fn {}
+unsafe impl Send for QcomExtension519Fn {}
+unsafe impl Sync for QcomExtension519Fn {}
+impl QcomExtension519Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QcomExtension520Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_520\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct QcomExtension520Fn {}
+unsafe impl Send for QcomExtension520Fn {}
+unsafe impl Sync for QcomExtension520Fn {}
+impl QcomExtension520Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QcomExtension521Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_521\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct QcomExtension521Fn {}
+unsafe impl Send for QcomExtension521Fn {}
+unsafe impl Sync for QcomExtension521Fn {}
+impl QcomExtension521Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QcomExtension522Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_522\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct QcomExtension522Fn {}
+unsafe impl Send for QcomExtension522Fn {}
+unsafe impl Sync for QcomExtension522Fn {}
+impl QcomExtension522Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension523Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_523\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension523Fn {}
+unsafe impl Send for ExtExtension523Fn {}
+unsafe impl Sync for ExtExtension523Fn {}
+impl ExtExtension523Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension524Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_524\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension524Fn {}
+unsafe impl Send for ExtExtension524Fn {}
+unsafe impl Sync for ExtExtension524Fn {}
+impl ExtExtension524Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtAttachmentFeedbackLoopDynamicStateFn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe {
+            ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                b"VK_EXT_attachment_feedback_loop_dynamic_state\0",
+            )
+        }
+    }
+    pub const SPEC_VERSION: u32 = 1u32;
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, aspect_mask: ImageAspectFlags);
+#[derive(Clone)]
+pub struct ExtAttachmentFeedbackLoopDynamicStateFn {
+    pub cmd_set_attachment_feedback_loop_enable_ext: PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT,
+}
+unsafe impl Send for ExtAttachmentFeedbackLoopDynamicStateFn {}
+unsafe impl Sync for ExtAttachmentFeedbackLoopDynamicStateFn {}
+impl ExtAttachmentFeedbackLoopDynamicStateFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            cmd_set_attachment_feedback_loop_enable_ext: unsafe {
+                unsafe extern "system" fn cmd_set_attachment_feedback_loop_enable_ext(
+                    _command_buffer: CommandBuffer,
+                    _aspect_mask: ImageAspectFlags,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_attachment_feedback_loop_enable_ext)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetAttachmentFeedbackLoopEnableEXT\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_attachment_feedback_loop_enable_ext
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_dynamic_state'"]
+impl DynamicState {
+    pub const ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: Self = Self(1_000_524_000);
+}
+#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_dynamic_state'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: Self =
+        Self(1_000_524_000);
+}
+impl ExtExtension526Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_526\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension526Fn {}
+unsafe impl Send for ExtExtension526Fn {}
+unsafe impl Sync for ExtExtension526Fn {}
+impl ExtExtension526Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension527Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_527\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension527Fn {}
+unsafe impl Send for ExtExtension527Fn {}
+unsafe impl Sync for ExtExtension527Fn {}
+impl ExtExtension527Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl ExtExtension528Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_528\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct ExtExtension528Fn {}
+unsafe impl Send for ExtExtension528Fn {}
+unsafe impl Sync for ExtExtension528Fn {}
+impl ExtExtension528Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl KhrExtension529Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_529\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct KhrExtension529Fn {}
+unsafe impl Send for KhrExtension529Fn {}
+unsafe impl Sync for KhrExtension529Fn {}
+impl KhrExtension529Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl QnxExtension530Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_extension_530\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct QnxExtension530Fn {}
+unsafe impl Send for QnxExtension530Fn {}
+unsafe impl Sync for QnxExtension530Fn {}
+impl QnxExtension530Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[doc = "Generated from 'VK_QNX_extension_530'"]
+impl ExternalMemoryHandleTypeFlags {
+    pub const TYPE_530_QNX: Self = Self(0b100_0000_0000_0000);
+}
+impl MsftExtension531Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MSFT_extension_531\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct MsftExtension531Fn {}
+unsafe impl Send for MsftExtension531Fn {}
+unsafe impl Sync for MsftExtension531Fn {}
+impl MsftExtension531Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+impl KhrExtension532Fn {
+    #[inline]
+    pub const fn name() -> &'static ::std::ffi::CStr {
+        unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_532\0") }
+    }
+    pub const SPEC_VERSION: u32 = 0u32;
+}
+#[derive(Clone)]
+pub struct KhrExtension532Fn {}
+unsafe impl Send for KhrExtension532Fn {}
+unsafe impl Sync for KhrExtension532Fn {}
+impl KhrExtension532Fn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
 }
diff --git a/src/vk/feature_extensions.rs b/src/vk/feature_extensions.rs
index e88e9df..4b1820c 100644
--- a/src/vk/feature_extensions.rs
+++ b/src/vk/feature_extensions.rs
@@ -1,807 +1,451 @@
 use crate::vk::bitflags::*;
 use crate::vk::enums::*;
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = Self(1_000_094_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const BIND_BUFFER_MEMORY_INFO: Self = Self(1_000_157_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const BIND_IMAGE_MEMORY_INFO: Self = Self(1_000_157_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageCreateFlags {
-    pub const ALIAS: Self = Self(0b100_0000_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = Self(1_000_083_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const MEMORY_DEDICATED_REQUIREMENTS: Self = Self(1_000_127_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = Self(1_000_127_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = Self(1_000_060_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = Self(1_000_060_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = Self(1_000_060_004);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const DEVICE_GROUP_SUBMIT_INFO: Self = Self(1_000_060_005);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = Self(1_000_060_006);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl PipelineCreateFlags {
-    pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(0b1000);
+impl BufferCreateFlags {
+    #[doc = "Buffer requires protected memory"]
+    pub const PROTECTED: Self = Self(0b1000);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl PipelineCreateFlags {
-    pub const DISPATCH_BASE: Self = Self(0b1_0000);
+impl CommandPoolCreateFlags {
+    #[doc = "Command buffers allocated from pool are protected command buffers"]
+    pub const PROTECTED: Self = Self(0b100);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
 impl DependencyFlags {
+    #[doc = "Dependency is across devices"]
     pub const DEVICE_GROUP: Self = Self(0b100);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = Self(1_000_060_013);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = Self(1_000_060_014);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageCreateFlags {
-    pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(0b100_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = Self(1_000_070_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = Self(1_000_070_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl MemoryHeapFlags {
-    pub const MULTI_INSTANCE: Self = Self(0b10);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const MEMORY_REQUIREMENTS_2: Self = Self(1_000_146_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = Self(1_000_146_004);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_FEATURES_2: Self = Self(1_000_059_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = Self(1_000_059_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const FORMAT_PROPERTIES_2: Self = Self(1_000_059_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const IMAGE_FORMAT_PROPERTIES_2: Self = Self(1_000_059_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = Self(1_000_059_004);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const QUEUE_FAMILY_PROPERTIES_2: Self = Self(1_000_059_005);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = Self(1_000_059_006);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = Self(1_000_059_007);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = Self(1_000_059_008);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Result {
-    pub const ERROR_OUT_OF_POOL_MEMORY: Self = Self(-1000069000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl FormatFeatureFlags {
-    pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl FormatFeatureFlags {
-    pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageCreateFlags {
-    pub const TYPE_2D_ARRAY_COMPATIBLE: Self = Self(0b10_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageCreateFlags {
-    pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = Self(0b1000_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageCreateFlags {
-    pub const EXTENDED_USAGE: Self = Self(0b1_0000_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = Self(1_000_117_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = Self(1_000_117_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = Self(1_000_117_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = Self(1_000_117_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageLayout {
-    pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1_000_117_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageLayout {
-    pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = Self(1_000_117_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = Self(1_000_053_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = Self(1_000_053_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = Self(1_000_053_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl DependencyFlags {
     pub const VIEW_LOCAL: Self = Self(0b10);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: Self = Self(1_000_120_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self =
-        Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PROTECTED_SUBMIT_INFO: Self = Self(1_000_145_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = Self(1_000_145_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = Self(1_000_145_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const DEVICE_QUEUE_INFO_2: Self = Self(1_000_145_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl QueueFlags {
-    pub const PROTECTED: Self = Self(0b1_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
 impl DeviceQueueCreateFlags {
+    #[doc = "Queue is a protected-capable device queue"]
     pub const PROTECTED: Self = Self(0b1);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl MemoryPropertyFlags {
-    pub const PROTECTED: Self = Self(0b10_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl BufferCreateFlags {
-    pub const PROTECTED: Self = Self(0b1000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageCreateFlags {
-    pub const PROTECTED: Self = Self(0b1000_0000_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl CommandPoolCreateFlags {
-    pub const PROTECTED: Self = Self(0b100);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = Self(1_000_156_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = Self(1_000_156_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = Self(1_000_156_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = Self(1_000_156_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = Self(1_000_156_004);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
-    pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = Self(1_000_156_005);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ObjectType {
-    pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
 impl Format {
     pub const G8B8G8R8_422_UNORM: Self = Self(1_000_156_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const B8G8R8G8_422_UNORM: Self = Self(1_000_156_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G8_B8_R8_3PLANE_420_UNORM: Self = Self(1_000_156_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G8_B8R8_2PLANE_420_UNORM: Self = Self(1_000_156_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G8_B8_R8_3PLANE_422_UNORM: Self = Self(1_000_156_004);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G8_B8R8_2PLANE_422_UNORM: Self = Self(1_000_156_005);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G8_B8_R8_3PLANE_444_UNORM: Self = Self(1_000_156_006);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const R10X6_UNORM_PACK16: Self = Self(1_000_156_007);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const R10X6G10X6_UNORM_2PACK16: Self = Self(1_000_156_008);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Self(1_000_156_009);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Self(1_000_156_010);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Self(1_000_156_011);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_012);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_013);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_014);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_015);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Self(1_000_156_016);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const R12X4_UNORM_PACK16: Self = Self(1_000_156_017);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const R12X4G12X4_UNORM_2PACK16: Self = Self(1_000_156_018);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Self(1_000_156_019);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Self(1_000_156_020);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Self(1_000_156_021);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_022);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Self(1_000_156_023);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_024);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Self(1_000_156_025);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Self(1_000_156_026);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G16B16G16R16_422_UNORM: Self = Self(1_000_156_027);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const B16G16R16G16_422_UNORM: Self = Self(1_000_156_028);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G16_B16_R16_3PLANE_420_UNORM: Self = Self(1_000_156_029);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G16_B16R16_2PLANE_420_UNORM: Self = Self(1_000_156_030);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G16_B16_R16_3PLANE_422_UNORM: Self = Self(1_000_156_031);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G16_B16R16_2PLANE_422_UNORM: Self = Self(1_000_156_032);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Format {
     pub const G16_B16_R16_3PLANE_444_UNORM: Self = Self(1_000_156_033);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageAspectFlags {
-    pub const PLANE_0: Self = Self(0b1_0000);
+impl FormatFeatureFlags {
+    #[doc = "Format can be used as the source image of image transfer commands"]
+    pub const TRANSFER_SRC: Self = Self(0b100_0000_0000_0000);
+    #[doc = "Format can be used as the destination image of image transfer commands"]
+    pub const TRANSFER_DST: Self = Self(0b1000_0000_0000_0000);
+    #[doc = "Format can have midpoint rather than cosited chroma samples"]
+    pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000);
+    #[doc = "Format can be used with linear filtering whilst color conversion is enabled"]
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000);
+    #[doc = "Format can have different chroma, min and mag filters"]
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self =
+        Self(0b1000_0000_0000_0000_0000);
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self =
+        Self(0b1_0000_0000_0000_0000_0000);
+    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self =
+        Self(0b10_0000_0000_0000_0000_0000);
+    #[doc = "Format supports disjoint planes"]
+    pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000);
+    #[doc = "Format can have cosited rather than midpoint chroma samples"]
+    pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
 impl ImageAspectFlags {
+    pub const PLANE_0: Self = Self(0b1_0000);
     pub const PLANE_1: Self = Self(0b10_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ImageAspectFlags {
     pub const PLANE_2: Self = Self(0b100_0000);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
 impl ImageCreateFlags {
+    pub const ALIAS: Self = Self(0b100_0000_0000);
+    #[doc = "Allows using VkBindImageMemoryDeviceGroupInfo::pSplitInstanceBindRegions when binding memory to the image"]
+    pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(0b100_0000);
+    #[doc = "The 3D image can be viewed as a 2D or 2D array image"]
+    pub const TYPE_2D_ARRAY_COMPATIBLE: Self = Self(0b10_0000);
+    pub const BLOCK_TEXEL_VIEW_COMPATIBLE: Self = Self(0b1000_0000);
+    pub const EXTENDED_USAGE: Self = Self(0b1_0000_0000);
+    #[doc = "Image requires protected memory"]
+    pub const PROTECTED: Self = Self(0b1000_0000_0000);
     pub const DISJOINT: Self = Self(0b10_0000_0000);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl FormatFeatureFlags {
-    pub const MIDPOINT_CHROMA_SAMPLES: Self = Self(0b10_0000_0000_0000_0000);
+impl ImageLayout {
+    pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1_000_117_000);
+    pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = Self(1_000_117_001);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl FormatFeatureFlags {
-    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER: Self = Self(0b100_0000_0000_0000_0000);
+impl MemoryHeapFlags {
+    #[doc = "If set, heap allocations allocate multiple instances by default"]
+    pub const MULTI_INSTANCE: Self = Self(0b10);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl FormatFeatureFlags {
-    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER: Self =
-        Self(0b1000_0000_0000_0000_0000);
+impl MemoryPropertyFlags {
+    #[doc = "Memory is protected"]
+    pub const PROTECTED: Self = Self(0b10_0000);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl FormatFeatureFlags {
-    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT: Self =
-        Self(0b1_0000_0000_0000_0000_0000);
+impl ObjectType {
+    pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000);
+    pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl FormatFeatureFlags {
-    pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE: Self =
-        Self(0b10_0000_0000_0000_0000_0000);
+impl PipelineCreateFlags {
+    pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(0b1000);
+    pub const DISPATCH_BASE: Self = Self(0b1_0000);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl FormatFeatureFlags {
-    pub const DISJOINT: Self = Self(0b100_0000_0000_0000_0000_0000);
+impl QueueFlags {
+    #[doc = "Queues may support protected operations"]
+    pub const PROTECTED: Self = Self(0b1_0000);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
-impl FormatFeatureFlags {
-    pub const COSITED_CHROMA_SAMPLES: Self = Self(0b1000_0000_0000_0000_0000_0000);
+impl Result {
+    pub const ERROR_OUT_OF_POOL_MEMORY: Self = Self(-1_000_069_000);
+    pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Self(-1_000_072_003);
 }
 #[doc = "Generated from 'VK_VERSION_1_1'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = Self(1_000_094_000);
+    pub const BIND_BUFFER_MEMORY_INFO: Self = Self(1_000_157_000);
+    pub const BIND_IMAGE_MEMORY_INFO: Self = Self(1_000_157_001);
+    pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = Self(1_000_083_000);
+    pub const MEMORY_DEDICATED_REQUIREMENTS: Self = Self(1_000_127_000);
+    pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = Self(1_000_127_001);
+    pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = Self(1_000_060_000);
+    pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = Self(1_000_060_003);
+    pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = Self(1_000_060_004);
+    pub const DEVICE_GROUP_SUBMIT_INFO: Self = Self(1_000_060_005);
+    pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = Self(1_000_060_006);
+    pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = Self(1_000_060_013);
+    pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = Self(1_000_060_014);
+    pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = Self(1_000_070_000);
+    pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = Self(1_000_070_001);
+    pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_000);
+    pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_001);
+    pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1_000_146_002);
+    pub const MEMORY_REQUIREMENTS_2: Self = Self(1_000_146_003);
+    pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = Self(1_000_146_004);
+    pub const PHYSICAL_DEVICE_FEATURES_2: Self = Self(1_000_059_000);
+    pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = Self(1_000_059_001);
+    pub const FORMAT_PROPERTIES_2: Self = Self(1_000_059_002);
+    pub const IMAGE_FORMAT_PROPERTIES_2: Self = Self(1_000_059_003);
+    pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = Self(1_000_059_004);
+    pub const QUEUE_FAMILY_PROPERTIES_2: Self = Self(1_000_059_005);
+    pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = Self(1_000_059_006);
+    pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = Self(1_000_059_007);
+    pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = Self(1_000_059_008);
+    pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = Self(1_000_117_000);
+    pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = Self(1_000_117_001);
+    pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = Self(1_000_117_002);
+    pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = Self(1_000_117_003);
+    pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = Self(1_000_053_000);
+    pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = Self(1_000_053_001);
+    pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = Self(1_000_053_002);
+    pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: Self = Self(1_000_120_000);
+    pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self =
+        Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
+    pub const PROTECTED_SUBMIT_INFO: Self = Self(1_000_145_000);
+    pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = Self(1_000_145_001);
+    pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = Self(1_000_145_002);
+    pub const DEVICE_QUEUE_INFO_2: Self = Self(1_000_145_003);
+    pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = Self(1_000_156_000);
+    pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = Self(1_000_156_001);
+    pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = Self(1_000_156_002);
+    pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = Self(1_000_156_003);
+    pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = Self(1_000_156_004);
+    pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = Self(1_000_156_005);
     pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = Self(1_000_085_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl ObjectType {
-    pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = Self(1_000_071_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = Self(1_000_071_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = Self(1_000_071_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const EXTERNAL_BUFFER_PROPERTIES: Self = Self(1_000_071_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = Self(1_000_071_004);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = Self(1_000_072_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = Self(1_000_072_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = Self(1_000_072_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl Result {
-    pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Self(-1000072003);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = Self(1_000_112_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const EXTERNAL_FENCE_PROPERTIES: Self = Self(1_000_112_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const EXPORT_FENCE_CREATE_INFO: Self = Self(1_000_113_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = Self(1_000_077_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = Self(1_000_076_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = Self(1_000_076_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = Self(1_000_168_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = Self(1_000_168_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: Self = Self(1_000_063_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_1'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self =
         Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: Self = Self(49);
+impl BufferCreateFlags {
+    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1_0000);
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: Self = Self(50);
+impl BufferUsageFlags {
+    pub const SHADER_DEVICE_ADDRESS: Self = Self(0b10_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: Self = Self(51);
+impl DescriptorPoolCreateFlags {
+    pub const UPDATE_AFTER_BIND: Self = Self(0b10);
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
-    pub const PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: Self = Self(52);
+impl DescriptorSetLayoutCreateFlags {
+    pub const UPDATE_AFTER_BIND_POOL: Self = Self(0b10);
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
-    pub const IMAGE_FORMAT_LIST_CREATE_INFO: Self = Self(1_000_147_000);
+impl FormatFeatureFlags {
+    #[doc = "Format can be used with min/max reduction filtering"]
+    pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000);
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
-    pub const ATTACHMENT_DESCRIPTION_2: Self = Self(1_000_109_000);
+impl FramebufferCreateFlags {
+    pub const IMAGELESS: Self = Self(0b1);
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
-    pub const ATTACHMENT_REFERENCE_2: Self = Self(1_000_109_001);
+impl ImageLayout {
+    pub const DEPTH_ATTACHMENT_OPTIMAL: Self = Self(1_000_241_000);
+    pub const DEPTH_READ_ONLY_OPTIMAL: Self = Self(1_000_241_001);
+    pub const STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1_000_241_002);
+    pub const STENCIL_READ_ONLY_OPTIMAL: Self = Self(1_000_241_003);
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
-    pub const SUBPASS_DESCRIPTION_2: Self = Self(1_000_109_002);
+impl MemoryAllocateFlags {
+    pub const DEVICE_ADDRESS: Self = Self(0b10);
+    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b100);
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
-    pub const SUBPASS_DEPENDENCY_2: Self = Self(1_000_109_003);
+impl Result {
+    pub const ERROR_FRAGMENTATION: Self = Self(-1_000_161_000);
+    pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: Self = Self(-1_000_257_000);
 }
 #[doc = "Generated from 'VK_VERSION_1_2'"]
 impl StructureType {
+    pub const PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: Self = Self(49);
+    pub const PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: Self = Self(50);
+    pub const PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: Self = Self(51);
+    pub const PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: Self = Self(52);
+    pub const IMAGE_FORMAT_LIST_CREATE_INFO: Self = Self(1_000_147_000);
+    pub const ATTACHMENT_DESCRIPTION_2: Self = Self(1_000_109_000);
+    pub const ATTACHMENT_REFERENCE_2: Self = Self(1_000_109_001);
+    pub const SUBPASS_DESCRIPTION_2: Self = Self(1_000_109_002);
+    pub const SUBPASS_DEPENDENCY_2: Self = Self(1_000_109_003);
     pub const RENDER_PASS_CREATE_INFO_2: Self = Self(1_000_109_004);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const SUBPASS_BEGIN_INFO: Self = Self(1_000_109_005);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const SUBPASS_END_INFO: Self = Self(1_000_109_006);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: Self = Self(1_000_177_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES: Self = Self(1_000_196_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: Self = Self(1_000_180_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: Self = Self(1_000_082_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: Self = Self(1_000_197_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: Self = Self(1_000_161_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: Self = Self(1_000_161_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: Self = Self(1_000_161_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: Self = Self(1_000_161_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: Self = Self(1_000_161_004);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl DescriptorPoolCreateFlags {
-    pub const UPDATE_AFTER_BIND: Self = Self(0b10);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl DescriptorSetLayoutCreateFlags {
-    pub const UPDATE_AFTER_BIND_POOL: Self = Self(0b10);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl Result {
-    pub const ERROR_FRAGMENTATION: Self = Self(-1000161000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: Self = Self(1_000_199_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: Self = Self(1_000_199_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: Self = Self(1_000_221_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const IMAGE_STENCIL_USAGE_CREATE_INFO: Self = Self(1_000_246_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: Self = Self(1_000_130_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const SAMPLER_REDUCTION_MODE_CREATE_INFO: Self = Self(1_000_130_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl FormatFeatureFlags {
-    pub const SAMPLED_IMAGE_FILTER_MINMAX: Self = Self(0b1_0000_0000_0000_0000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: Self = Self(1_000_211_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: Self = Self(1_000_108_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: Self = Self(1_000_108_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: Self = Self(1_000_108_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO: Self = Self(1_000_108_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl FramebufferCreateFlags {
-    pub const IMAGELESS: Self = Self(0b1);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: Self = Self(1_000_253_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: Self = Self(1_000_175_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: Self = Self(1_000_241_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT: Self = Self(1_000_241_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: Self = Self(1_000_241_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl ImageLayout {
-    pub const DEPTH_ATTACHMENT_OPTIMAL: Self = Self(1_000_241_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl ImageLayout {
-    pub const DEPTH_READ_ONLY_OPTIMAL: Self = Self(1_000_241_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl ImageLayout {
-    pub const STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1_000_241_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl ImageLayout {
-    pub const STENCIL_READ_ONLY_OPTIMAL: Self = Self(1_000_241_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: Self = Self(1_000_261_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: Self = Self(1_000_207_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: Self = Self(1_000_207_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const SEMAPHORE_TYPE_CREATE_INFO: Self = Self(1_000_207_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const TIMELINE_SEMAPHORE_SUBMIT_INFO: Self = Self(1_000_207_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const SEMAPHORE_WAIT_INFO: Self = Self(1_000_207_004);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const SEMAPHORE_SIGNAL_INFO: Self = Self(1_000_207_005);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: Self = Self(1_000_257_000);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const BUFFER_DEVICE_ADDRESS_INFO: Self = Self(1_000_244_001);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: Self = Self(1_000_257_002);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: Self = Self(1_000_257_003);
-}
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl StructureType {
     pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: Self = Self(1_000_257_004);
 }
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl BufferUsageFlags {
-    pub const SHADER_DEVICE_ADDRESS: Self = Self(0b10_0000_0000_0000_0000);
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl AccessFlags {
+    pub const NONE: Self = Self(0);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl AttachmentStoreOp {
+    pub const NONE: Self = Self(1_000_301_000);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl DescriptorType {
+    pub const INLINE_UNIFORM_BLOCK: Self = Self(1_000_138_000);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl DynamicState {
+    pub const CULL_MODE: Self = Self(1_000_267_000);
+    pub const FRONT_FACE: Self = Self(1_000_267_001);
+    pub const PRIMITIVE_TOPOLOGY: Self = Self(1_000_267_002);
+    pub const VIEWPORT_WITH_COUNT: Self = Self(1_000_267_003);
+    pub const SCISSOR_WITH_COUNT: Self = Self(1_000_267_004);
+    pub const VERTEX_INPUT_BINDING_STRIDE: Self = Self(1_000_267_005);
+    pub const DEPTH_TEST_ENABLE: Self = Self(1_000_267_006);
+    pub const DEPTH_WRITE_ENABLE: Self = Self(1_000_267_007);
+    pub const DEPTH_COMPARE_OP: Self = Self(1_000_267_008);
+    pub const DEPTH_BOUNDS_TEST_ENABLE: Self = Self(1_000_267_009);
+    pub const STENCIL_TEST_ENABLE: Self = Self(1_000_267_010);
+    pub const STENCIL_OP: Self = Self(1_000_267_011);
+    pub const RASTERIZER_DISCARD_ENABLE: Self = Self(1_000_377_001);
+    pub const DEPTH_BIAS_ENABLE: Self = Self(1_000_377_002);
+    pub const PRIMITIVE_RESTART_ENABLE: Self = Self(1_000_377_004);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl EventCreateFlags {
+    pub const DEVICE_ONLY: Self = Self(0b1);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl Format {
+    pub const G8_B8R8_2PLANE_444_UNORM: Self = Self(1_000_330_000);
+    pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: Self = Self(1_000_330_001);
+    pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: Self = Self(1_000_330_002);
+    pub const G16_B16R16_2PLANE_444_UNORM: Self = Self(1_000_330_003);
+    pub const A4R4G4B4_UNORM_PACK16: Self = Self(1_000_340_000);
+    pub const A4B4G4R4_UNORM_PACK16: Self = Self(1_000_340_001);
+    pub const ASTC_4X4_SFLOAT_BLOCK: Self = Self(1_000_066_000);
+    pub const ASTC_5X4_SFLOAT_BLOCK: Self = Self(1_000_066_001);
+    pub const ASTC_5X5_SFLOAT_BLOCK: Self = Self(1_000_066_002);
+    pub const ASTC_6X5_SFLOAT_BLOCK: Self = Self(1_000_066_003);
+    pub const ASTC_6X6_SFLOAT_BLOCK: Self = Self(1_000_066_004);
+    pub const ASTC_8X5_SFLOAT_BLOCK: Self = Self(1_000_066_005);
+    pub const ASTC_8X6_SFLOAT_BLOCK: Self = Self(1_000_066_006);
+    pub const ASTC_8X8_SFLOAT_BLOCK: Self = Self(1_000_066_007);
+    pub const ASTC_10X5_SFLOAT_BLOCK: Self = Self(1_000_066_008);
+    pub const ASTC_10X6_SFLOAT_BLOCK: Self = Self(1_000_066_009);
+    pub const ASTC_10X8_SFLOAT_BLOCK: Self = Self(1_000_066_010);
+    pub const ASTC_10X10_SFLOAT_BLOCK: Self = Self(1_000_066_011);
+    pub const ASTC_12X10_SFLOAT_BLOCK: Self = Self(1_000_066_012);
+    pub const ASTC_12X12_SFLOAT_BLOCK: Self = Self(1_000_066_013);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl ImageAspectFlags {
+    pub const NONE: Self = Self(0);
 }
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl BufferCreateFlags {
-    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1_0000);
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl ImageLayout {
+    pub const READ_ONLY_OPTIMAL: Self = Self(1_000_314_000);
+    pub const ATTACHMENT_OPTIMAL: Self = Self(1_000_314_001);
 }
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl MemoryAllocateFlags {
-    pub const DEVICE_ADDRESS: Self = Self(0b10);
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl ObjectType {
+    pub const PRIVATE_DATA_SLOT: Self = Self(1_000_295_000);
 }
-#[doc = "Generated from 'VK_VERSION_1_2'"]
-impl MemoryAllocateFlags {
-    pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b100);
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl PipelineCacheCreateFlags {
+    pub const EXTERNALLY_SYNCHRONIZED: Self = Self(0b1);
 }
-#[doc = "Generated from 'VK_VERSION_1_2'"]
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl PipelineCreateFlags {
+    pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED: Self = Self(0b1_0000_0000);
+    pub const EARLY_RETURN_ON_FAILURE: Self = Self(0b10_0000_0000);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl PipelineShaderStageCreateFlags {
+    pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(0b1);
+    pub const REQUIRE_FULL_SUBGROUPS: Self = Self(0b10);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl PipelineStageFlags {
+    pub const NONE: Self = Self(0);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
 impl Result {
-    pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: Self = Self(-1000257000);
+    pub const PIPELINE_COMPILE_REQUIRED: Self = Self(1_000_297_000);
+}
+#[doc = "Generated from 'VK_VERSION_1_3'"]
+impl StructureType {
+    pub const PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: Self = Self(53);
+    pub const PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: Self = Self(54);
+    pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO: Self = Self(1_000_192_000);
+    pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: Self = Self(1_000_215_000);
+    pub const PHYSICAL_DEVICE_TOOL_PROPERTIES: Self = Self(1_000_245_000);
+    pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: Self =
+        Self(1_000_276_000);
+    pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: Self = Self(1_000_295_000);
+    pub const DEVICE_PRIVATE_DATA_CREATE_INFO: Self = Self(1_000_295_001);
+    pub const PRIVATE_DATA_SLOT_CREATE_INFO: Self = Self(1_000_295_002);
+    pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: Self = Self(1_000_297_000);
+    pub const MEMORY_BARRIER_2: Self = Self(1_000_314_000);
+    pub const BUFFER_MEMORY_BARRIER_2: Self = Self(1_000_314_001);
+    pub const IMAGE_MEMORY_BARRIER_2: Self = Self(1_000_314_002);
+    pub const DEPENDENCY_INFO: Self = Self(1_000_314_003);
+    pub const SUBMIT_INFO_2: Self = Self(1_000_314_004);
+    pub const SEMAPHORE_SUBMIT_INFO: Self = Self(1_000_314_005);
+    pub const COMMAND_BUFFER_SUBMIT_INFO: Self = Self(1_000_314_006);
+    pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: Self = Self(1_000_314_007);
+    pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: Self = Self(1_000_325_000);
+    pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: Self = Self(1_000_335_000);
+    pub const COPY_BUFFER_INFO_2: Self = Self(1_000_337_000);
+    pub const COPY_IMAGE_INFO_2: Self = Self(1_000_337_001);
+    pub const COPY_BUFFER_TO_IMAGE_INFO_2: Self = Self(1_000_337_002);
+    pub const COPY_IMAGE_TO_BUFFER_INFO_2: Self = Self(1_000_337_003);
+    pub const BLIT_IMAGE_INFO_2: Self = Self(1_000_337_004);
+    pub const RESOLVE_IMAGE_INFO_2: Self = Self(1_000_337_005);
+    pub const BUFFER_COPY_2: Self = Self(1_000_337_006);
+    pub const IMAGE_COPY_2: Self = Self(1_000_337_007);
+    pub const IMAGE_BLIT_2: Self = Self(1_000_337_008);
+    pub const BUFFER_IMAGE_COPY_2: Self = Self(1_000_337_009);
+    pub const IMAGE_RESOLVE_2: Self = Self(1_000_337_010);
+    pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: Self = Self(1_000_225_000);
+    pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: Self = Self(1_000_225_001);
+    pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: Self = Self(1_000_225_002);
+    pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: Self = Self(1_000_138_000);
+    pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: Self = Self(1_000_138_001);
+    pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: Self = Self(1_000_138_002);
+    pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: Self = Self(1_000_138_003);
+    pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: Self = Self(1_000_066_000);
+    pub const RENDERING_INFO: Self = Self(1_000_044_000);
+    pub const RENDERING_ATTACHMENT_INFO: Self = Self(1_000_044_001);
+    pub const PIPELINE_RENDERING_CREATE_INFO: Self = Self(1_000_044_002);
+    pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: Self = Self(1_000_044_003);
+    pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: Self = Self(1_000_044_004);
+    pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: Self = Self(1_000_280_000);
+    pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: Self = Self(1_000_280_001);
+    pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: Self = Self(1_000_281_001);
+    pub const FORMAT_PROPERTIES_3: Self = Self(1_000_360_000);
+    pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: Self = Self(1_000_413_000);
+    pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: Self = Self(1_000_413_001);
+    pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS: Self = Self(1_000_413_002);
+    pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS: Self = Self(1_000_413_003);
 }
diff --git a/src/vk/features.rs b/src/vk/features.rs
index 0f490a6..f7ddc8e 100644
--- a/src/vk/features.rs
+++ b/src/vk/features.rs
@@ -16,7 +16,7 @@ impl StaticFn {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        StaticFn {
+        Self {
             get_instance_proc_addr: unsafe {
                 unsafe extern "system" fn get_instance_proc_addr(
                     _instance: Instance,
@@ -38,14 +38,6 @@ impl StaticFn {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetInstanceProcAddr.html>"]
-    pub unsafe fn get_instance_proc_addr(
-        &self,
-        instance: Instance,
-        p_name: *const c_char,
-    ) -> PFN_vkVoidFunction {
-        (self.get_instance_proc_addr)(instance, p_name)
-    }
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkCreateInstance = unsafe extern "system" fn(
@@ -77,7 +69,7 @@ impl EntryFnV1_0 {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        EntryFnV1_0 {
+        Self {
             create_instance: unsafe {
                 unsafe extern "system" fn create_instance(
                     _p_create_info: *const InstanceCreateInfo,
@@ -137,32 +129,6 @@ impl EntryFnV1_0 {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateInstance.html>"]
-    pub unsafe fn create_instance(
-        &self,
-        p_create_info: *const InstanceCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_instance: *mut Instance,
-    ) -> Result {
-        (self.create_instance)(p_create_info, p_allocator, p_instance)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceExtensionProperties.html>"]
-    pub unsafe fn enumerate_instance_extension_properties(
-        &self,
-        p_layer_name: *const c_char,
-        p_property_count: *mut u32,
-        p_properties: *mut ExtensionProperties,
-    ) -> Result {
-        (self.enumerate_instance_extension_properties)(p_layer_name, p_property_count, p_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceLayerProperties.html>"]
-    pub unsafe fn enumerate_instance_layer_properties(
-        &self,
-        p_property_count: *mut u32,
-        p_properties: *mut LayerProperties,
-    ) -> Result {
-        (self.enumerate_instance_layer_properties)(p_property_count, p_properties)
-    }
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkDestroyInstance =
@@ -268,7 +234,7 @@ impl InstanceFnV1_0 {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        InstanceFnV1_0 {
+        Self {
             destroy_instance: unsafe {
                 unsafe extern "system" fn destroy_instance(
                     _instance: Instance,
@@ -536,155 +502,6 @@ impl InstanceFnV1_0 {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyInstance.html>"]
-    pub unsafe fn destroy_instance(
-        &self,
-        instance: Instance,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_instance)(instance, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDevices.html>"]
-    pub unsafe fn enumerate_physical_devices(
-        &self,
-        instance: Instance,
-        p_physical_device_count: *mut u32,
-        p_physical_devices: *mut PhysicalDevice,
-    ) -> Result {
-        (self.enumerate_physical_devices)(instance, p_physical_device_count, p_physical_devices)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures.html>"]
-    pub unsafe fn get_physical_device_features(
-        &self,
-        physical_device: PhysicalDevice,
-        p_features: *mut PhysicalDeviceFeatures,
-    ) {
-        (self.get_physical_device_features)(physical_device, p_features)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties.html>"]
-    pub unsafe fn get_physical_device_format_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        format: Format,
-        p_format_properties: *mut FormatProperties,
-    ) {
-        (self.get_physical_device_format_properties)(physical_device, format, p_format_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties.html>"]
-    pub unsafe fn get_physical_device_image_format_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        format: Format,
-        ty: ImageType,
-        tiling: ImageTiling,
-        usage: ImageUsageFlags,
-        flags: ImageCreateFlags,
-        p_image_format_properties: *mut ImageFormatProperties,
-    ) -> Result {
-        (self.get_physical_device_image_format_properties)(
-            physical_device,
-            format,
-            ty,
-            tiling,
-            usage,
-            flags,
-            p_image_format_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties.html>"]
-    pub unsafe fn get_physical_device_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        p_properties: *mut PhysicalDeviceProperties,
-    ) {
-        (self.get_physical_device_properties)(physical_device, p_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html>"]
-    pub unsafe fn get_physical_device_queue_family_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        p_queue_family_property_count: *mut u32,
-        p_queue_family_properties: *mut QueueFamilyProperties,
-    ) {
-        (self.get_physical_device_queue_family_properties)(
-            physical_device,
-            p_queue_family_property_count,
-            p_queue_family_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties.html>"]
-    pub unsafe fn get_physical_device_memory_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        p_memory_properties: *mut PhysicalDeviceMemoryProperties,
-    ) {
-        (self.get_physical_device_memory_properties)(physical_device, p_memory_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceProcAddr.html>"]
-    pub unsafe fn get_device_proc_addr(
-        &self,
-        device: Device,
-        p_name: *const c_char,
-    ) -> PFN_vkVoidFunction {
-        (self.get_device_proc_addr)(device, p_name)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDevice.html>"]
-    pub unsafe fn create_device(
-        &self,
-        physical_device: PhysicalDevice,
-        p_create_info: *const DeviceCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_device: *mut Device,
-    ) -> Result {
-        (self.create_device)(physical_device, p_create_info, p_allocator, p_device)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateDeviceExtensionProperties.html>"]
-    pub unsafe fn enumerate_device_extension_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        p_layer_name: *const c_char,
-        p_property_count: *mut u32,
-        p_properties: *mut ExtensionProperties,
-    ) -> Result {
-        (self.enumerate_device_extension_properties)(
-            physical_device,
-            p_layer_name,
-            p_property_count,
-            p_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateDeviceLayerProperties.html>"]
-    pub unsafe fn enumerate_device_layer_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        p_property_count: *mut u32,
-        p_properties: *mut LayerProperties,
-    ) -> Result {
-        (self.enumerate_device_layer_properties)(physical_device, p_property_count, p_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html>"]
-    pub unsafe fn get_physical_device_sparse_image_format_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        format: Format,
-        ty: ImageType,
-        samples: SampleCountFlags,
-        usage: ImageUsageFlags,
-        tiling: ImageTiling,
-        p_property_count: *mut u32,
-        p_properties: *mut SparseImageFormatProperties,
-    ) {
-        (self.get_physical_device_sparse_image_format_properties)(
-            physical_device,
-            format,
-            ty,
-            samples,
-            usage,
-            tiling,
-            p_property_count,
-            p_properties,
-        )
-    }
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkDestroyDevice =
@@ -1182,7 +999,7 @@ pub type PFN_vkCmdSetDepthBias = unsafe extern "system" fn(
 );
 #[allow(non_camel_case_types)]
 pub type PFN_vkCmdSetBlendConstants =
-    unsafe extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4]);
+    unsafe extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4usize]);
 #[allow(non_camel_case_types)]
 pub type PFN_vkCmdSetDepthBounds = unsafe extern "system" fn(
     command_buffer: CommandBuffer,
@@ -1605,7 +1422,7 @@ impl DeviceFnV1_0 {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        DeviceFnV1_0 {
+        Self {
             destroy_device: unsafe {
                 unsafe extern "system" fn destroy_device(
                     _device: Device,
@@ -3059,7 +2876,7 @@ impl DeviceFnV1_0 {
             cmd_set_blend_constants: unsafe {
                 unsafe extern "system" fn cmd_set_blend_constants(
                     _command_buffer: CommandBuffer,
-                    _blend_constants: *const [f32; 4],
+                    _blend_constants: *const [f32; 4usize],
                 ) {
                     panic!(concat!(
                         "Unable to load ",
@@ -3826,1328 +3643,6 @@ impl DeviceFnV1_0 {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDevice.html>"]
-    pub unsafe fn destroy_device(&self, device: Device, p_allocator: *const AllocationCallbacks) {
-        (self.destroy_device)(device, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceQueue.html>"]
-    pub unsafe fn get_device_queue(
-        &self,
-        device: Device,
-        queue_family_index: u32,
-        queue_index: u32,
-        p_queue: *mut Queue,
-    ) {
-        (self.get_device_queue)(device, queue_family_index, queue_index, p_queue)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueSubmit.html>"]
-    pub unsafe fn queue_submit(
-        &self,
-        queue: Queue,
-        submit_count: u32,
-        p_submits: *const SubmitInfo,
-        fence: Fence,
-    ) -> Result {
-        (self.queue_submit)(queue, submit_count, p_submits, fence)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueWaitIdle.html>"]
-    pub unsafe fn queue_wait_idle(&self, queue: Queue) -> Result {
-        (self.queue_wait_idle)(queue)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDeviceWaitIdle.html>"]
-    pub unsafe fn device_wait_idle(&self, device: Device) -> Result {
-        (self.device_wait_idle)(device)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateMemory.html>"]
-    pub unsafe fn allocate_memory(
-        &self,
-        device: Device,
-        p_allocate_info: *const MemoryAllocateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_memory: *mut DeviceMemory,
-    ) -> Result {
-        (self.allocate_memory)(device, p_allocate_info, p_allocator, p_memory)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeMemory.html>"]
-    pub unsafe fn free_memory(
-        &self,
-        device: Device,
-        memory: DeviceMemory,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.free_memory)(device, memory, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMapMemory.html>"]
-    pub unsafe fn map_memory(
-        &self,
-        device: Device,
-        memory: DeviceMemory,
-        offset: DeviceSize,
-        size: DeviceSize,
-        flags: MemoryMapFlags,
-        pp_data: *mut *mut c_void,
-    ) -> Result {
-        (self.map_memory)(device, memory, offset, size, flags, pp_data)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUnmapMemory.html>"]
-    pub unsafe fn unmap_memory(&self, device: Device, memory: DeviceMemory) {
-        (self.unmap_memory)(device, memory)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFlushMappedMemoryRanges.html>"]
-    pub unsafe fn flush_mapped_memory_ranges(
-        &self,
-        device: Device,
-        memory_range_count: u32,
-        p_memory_ranges: *const MappedMemoryRange,
-    ) -> Result {
-        (self.flush_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkInvalidateMappedMemoryRanges.html>"]
-    pub unsafe fn invalidate_mapped_memory_ranges(
-        &self,
-        device: Device,
-        memory_range_count: u32,
-        p_memory_ranges: *const MappedMemoryRange,
-    ) -> Result {
-        (self.invalidate_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryCommitment.html>"]
-    pub unsafe fn get_device_memory_commitment(
-        &self,
-        device: Device,
-        memory: DeviceMemory,
-        p_committed_memory_in_bytes: *mut DeviceSize,
-    ) {
-        (self.get_device_memory_commitment)(device, memory, p_committed_memory_in_bytes)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindBufferMemory.html>"]
-    pub unsafe fn bind_buffer_memory(
-        &self,
-        device: Device,
-        buffer: Buffer,
-        memory: DeviceMemory,
-        memory_offset: DeviceSize,
-    ) -> Result {
-        (self.bind_buffer_memory)(device, buffer, memory, memory_offset)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindImageMemory.html>"]
-    pub unsafe fn bind_image_memory(
-        &self,
-        device: Device,
-        image: Image,
-        memory: DeviceMemory,
-        memory_offset: DeviceSize,
-    ) -> Result {
-        (self.bind_image_memory)(device, image, memory, memory_offset)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements.html>"]
-    pub unsafe fn get_buffer_memory_requirements(
-        &self,
-        device: Device,
-        buffer: Buffer,
-        p_memory_requirements: *mut MemoryRequirements,
-    ) {
-        (self.get_buffer_memory_requirements)(device, buffer, p_memory_requirements)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements.html>"]
-    pub unsafe fn get_image_memory_requirements(
-        &self,
-        device: Device,
-        image: Image,
-        p_memory_requirements: *mut MemoryRequirements,
-    ) {
-        (self.get_image_memory_requirements)(device, image, p_memory_requirements)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements.html>"]
-    pub unsafe fn get_image_sparse_memory_requirements(
-        &self,
-        device: Device,
-        image: Image,
-        p_sparse_memory_requirement_count: *mut u32,
-        p_sparse_memory_requirements: *mut SparseImageMemoryRequirements,
-    ) {
-        (self.get_image_sparse_memory_requirements)(
-            device,
-            image,
-            p_sparse_memory_requirement_count,
-            p_sparse_memory_requirements,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueBindSparse.html>"]
-    pub unsafe fn queue_bind_sparse(
-        &self,
-        queue: Queue,
-        bind_info_count: u32,
-        p_bind_info: *const BindSparseInfo,
-        fence: Fence,
-    ) -> Result {
-        (self.queue_bind_sparse)(queue, bind_info_count, p_bind_info, fence)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateFence.html>"]
-    pub unsafe fn create_fence(
-        &self,
-        device: Device,
-        p_create_info: *const FenceCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_fence: *mut Fence,
-    ) -> Result {
-        (self.create_fence)(device, p_create_info, p_allocator, p_fence)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyFence.html>"]
-    pub unsafe fn destroy_fence(
-        &self,
-        device: Device,
-        fence: Fence,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_fence)(device, fence, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetFences.html>"]
-    pub unsafe fn reset_fences(
-        &self,
-        device: Device,
-        fence_count: u32,
-        p_fences: *const Fence,
-    ) -> Result {
-        (self.reset_fences)(device, fence_count, p_fences)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetFenceStatus.html>"]
-    pub unsafe fn get_fence_status(&self, device: Device, fence: Fence) -> Result {
-        (self.get_fence_status)(device, fence)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitForFences.html>"]
-    pub unsafe fn wait_for_fences(
-        &self,
-        device: Device,
-        fence_count: u32,
-        p_fences: *const Fence,
-        wait_all: Bool32,
-        timeout: u64,
-    ) -> Result {
-        (self.wait_for_fences)(device, fence_count, p_fences, wait_all, timeout)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSemaphore.html>"]
-    pub unsafe fn create_semaphore(
-        &self,
-        device: Device,
-        p_create_info: *const SemaphoreCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_semaphore: *mut Semaphore,
-    ) -> Result {
-        (self.create_semaphore)(device, p_create_info, p_allocator, p_semaphore)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySemaphore.html>"]
-    pub unsafe fn destroy_semaphore(
-        &self,
-        device: Device,
-        semaphore: Semaphore,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_semaphore)(device, semaphore, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateEvent.html>"]
-    pub unsafe fn create_event(
-        &self,
-        device: Device,
-        p_create_info: *const EventCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_event: *mut Event,
-    ) -> Result {
-        (self.create_event)(device, p_create_info, p_allocator, p_event)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyEvent.html>"]
-    pub unsafe fn destroy_event(
-        &self,
-        device: Device,
-        event: Event,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_event)(device, event, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetEventStatus.html>"]
-    pub unsafe fn get_event_status(&self, device: Device, event: Event) -> Result {
-        (self.get_event_status)(device, event)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetEvent.html>"]
-    pub unsafe fn set_event(&self, device: Device, event: Event) -> Result {
-        (self.set_event)(device, event)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetEvent.html>"]
-    pub unsafe fn reset_event(&self, device: Device, event: Event) -> Result {
-        (self.reset_event)(device, event)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateQueryPool.html>"]
-    pub unsafe fn create_query_pool(
-        &self,
-        device: Device,
-        p_create_info: *const QueryPoolCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_query_pool: *mut QueryPool,
-    ) -> Result {
-        (self.create_query_pool)(device, p_create_info, p_allocator, p_query_pool)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyQueryPool.html>"]
-    pub unsafe fn destroy_query_pool(
-        &self,
-        device: Device,
-        query_pool: QueryPool,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_query_pool)(device, query_pool, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetQueryPoolResults.html>"]
-    pub unsafe fn get_query_pool_results(
-        &self,
-        device: Device,
-        query_pool: QueryPool,
-        first_query: u32,
-        query_count: u32,
-        data_size: usize,
-        p_data: *mut c_void,
-        stride: DeviceSize,
-        flags: QueryResultFlags,
-    ) -> Result {
-        (self.get_query_pool_results)(
-            device,
-            query_pool,
-            first_query,
-            query_count,
-            data_size,
-            p_data,
-            stride,
-            flags,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateBuffer.html>"]
-    pub unsafe fn create_buffer(
-        &self,
-        device: Device,
-        p_create_info: *const BufferCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_buffer: *mut Buffer,
-    ) -> Result {
-        (self.create_buffer)(device, p_create_info, p_allocator, p_buffer)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyBuffer.html>"]
-    pub unsafe fn destroy_buffer(
-        &self,
-        device: Device,
-        buffer: Buffer,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_buffer)(device, buffer, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateBufferView.html>"]
-    pub unsafe fn create_buffer_view(
-        &self,
-        device: Device,
-        p_create_info: *const BufferViewCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_view: *mut BufferView,
-    ) -> Result {
-        (self.create_buffer_view)(device, p_create_info, p_allocator, p_view)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyBufferView.html>"]
-    pub unsafe fn destroy_buffer_view(
-        &self,
-        device: Device,
-        buffer_view: BufferView,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_buffer_view)(device, buffer_view, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImage.html>"]
-    pub unsafe fn create_image(
-        &self,
-        device: Device,
-        p_create_info: *const ImageCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_image: *mut Image,
-    ) -> Result {
-        (self.create_image)(device, p_create_info, p_allocator, p_image)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyImage.html>"]
-    pub unsafe fn destroy_image(
-        &self,
-        device: Device,
-        image: Image,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_image)(device, image, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSubresourceLayout.html>"]
-    pub unsafe fn get_image_subresource_layout(
-        &self,
-        device: Device,
-        image: Image,
-        p_subresource: *const ImageSubresource,
-        p_layout: *mut SubresourceLayout,
-    ) {
-        (self.get_image_subresource_layout)(device, image, p_subresource, p_layout)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImageView.html>"]
-    pub unsafe fn create_image_view(
-        &self,
-        device: Device,
-        p_create_info: *const ImageViewCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_view: *mut ImageView,
-    ) -> Result {
-        (self.create_image_view)(device, p_create_info, p_allocator, p_view)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyImageView.html>"]
-    pub unsafe fn destroy_image_view(
-        &self,
-        device: Device,
-        image_view: ImageView,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_image_view)(device, image_view, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateShaderModule.html>"]
-    pub unsafe fn create_shader_module(
-        &self,
-        device: Device,
-        p_create_info: *const ShaderModuleCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_shader_module: *mut ShaderModule,
-    ) -> Result {
-        (self.create_shader_module)(device, p_create_info, p_allocator, p_shader_module)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyShaderModule.html>"]
-    pub unsafe fn destroy_shader_module(
-        &self,
-        device: Device,
-        shader_module: ShaderModule,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_shader_module)(device, shader_module, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreatePipelineCache.html>"]
-    pub unsafe fn create_pipeline_cache(
-        &self,
-        device: Device,
-        p_create_info: *const PipelineCacheCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_pipeline_cache: *mut PipelineCache,
-    ) -> Result {
-        (self.create_pipeline_cache)(device, p_create_info, p_allocator, p_pipeline_cache)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipelineCache.html>"]
-    pub unsafe fn destroy_pipeline_cache(
-        &self,
-        device: Device,
-        pipeline_cache: PipelineCache,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_pipeline_cache)(device, pipeline_cache, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineCacheData.html>"]
-    pub unsafe fn get_pipeline_cache_data(
-        &self,
-        device: Device,
-        pipeline_cache: PipelineCache,
-        p_data_size: *mut usize,
-        p_data: *mut c_void,
-    ) -> Result {
-        (self.get_pipeline_cache_data)(device, pipeline_cache, p_data_size, p_data)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMergePipelineCaches.html>"]
-    pub unsafe fn merge_pipeline_caches(
-        &self,
-        device: Device,
-        dst_cache: PipelineCache,
-        src_cache_count: u32,
-        p_src_caches: *const PipelineCache,
-    ) -> Result {
-        (self.merge_pipeline_caches)(device, dst_cache, src_cache_count, p_src_caches)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateGraphicsPipelines.html>"]
-    pub unsafe fn create_graphics_pipelines(
-        &self,
-        device: Device,
-        pipeline_cache: PipelineCache,
-        create_info_count: u32,
-        p_create_infos: *const GraphicsPipelineCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_pipelines: *mut Pipeline,
-    ) -> Result {
-        (self.create_graphics_pipelines)(
-            device,
-            pipeline_cache,
-            create_info_count,
-            p_create_infos,
-            p_allocator,
-            p_pipelines,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateComputePipelines.html>"]
-    pub unsafe fn create_compute_pipelines(
-        &self,
-        device: Device,
-        pipeline_cache: PipelineCache,
-        create_info_count: u32,
-        p_create_infos: *const ComputePipelineCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_pipelines: *mut Pipeline,
-    ) -> Result {
-        (self.create_compute_pipelines)(
-            device,
-            pipeline_cache,
-            create_info_count,
-            p_create_infos,
-            p_allocator,
-            p_pipelines,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipeline.html>"]
-    pub unsafe fn destroy_pipeline(
-        &self,
-        device: Device,
-        pipeline: Pipeline,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_pipeline)(device, pipeline, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreatePipelineLayout.html>"]
-    pub unsafe fn create_pipeline_layout(
-        &self,
-        device: Device,
-        p_create_info: *const PipelineLayoutCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_pipeline_layout: *mut PipelineLayout,
-    ) -> Result {
-        (self.create_pipeline_layout)(device, p_create_info, p_allocator, p_pipeline_layout)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipelineLayout.html>"]
-    pub unsafe fn destroy_pipeline_layout(
-        &self,
-        device: Device,
-        pipeline_layout: PipelineLayout,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_pipeline_layout)(device, pipeline_layout, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSampler.html>"]
-    pub unsafe fn create_sampler(
-        &self,
-        device: Device,
-        p_create_info: *const SamplerCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_sampler: *mut Sampler,
-    ) -> Result {
-        (self.create_sampler)(device, p_create_info, p_allocator, p_sampler)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySampler.html>"]
-    pub unsafe fn destroy_sampler(
-        &self,
-        device: Device,
-        sampler: Sampler,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_sampler)(device, sampler, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorSetLayout.html>"]
-    pub unsafe fn create_descriptor_set_layout(
-        &self,
-        device: Device,
-        p_create_info: *const DescriptorSetLayoutCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_set_layout: *mut DescriptorSetLayout,
-    ) -> Result {
-        (self.create_descriptor_set_layout)(device, p_create_info, p_allocator, p_set_layout)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorSetLayout.html>"]
-    pub unsafe fn destroy_descriptor_set_layout(
-        &self,
-        device: Device,
-        descriptor_set_layout: DescriptorSetLayout,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_descriptor_set_layout)(device, descriptor_set_layout, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorPool.html>"]
-    pub unsafe fn create_descriptor_pool(
-        &self,
-        device: Device,
-        p_create_info: *const DescriptorPoolCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_descriptor_pool: *mut DescriptorPool,
-    ) -> Result {
-        (self.create_descriptor_pool)(device, p_create_info, p_allocator, p_descriptor_pool)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorPool.html>"]
-    pub unsafe fn destroy_descriptor_pool(
-        &self,
-        device: Device,
-        descriptor_pool: DescriptorPool,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_descriptor_pool)(device, descriptor_pool, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetDescriptorPool.html>"]
-    pub unsafe fn reset_descriptor_pool(
-        &self,
-        device: Device,
-        descriptor_pool: DescriptorPool,
-        flags: DescriptorPoolResetFlags,
-    ) -> Result {
-        (self.reset_descriptor_pool)(device, descriptor_pool, flags)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateDescriptorSets.html>"]
-    pub unsafe fn allocate_descriptor_sets(
-        &self,
-        device: Device,
-        p_allocate_info: *const DescriptorSetAllocateInfo,
-        p_descriptor_sets: *mut DescriptorSet,
-    ) -> Result {
-        (self.allocate_descriptor_sets)(device, p_allocate_info, p_descriptor_sets)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeDescriptorSets.html>"]
-    pub unsafe fn free_descriptor_sets(
-        &self,
-        device: Device,
-        descriptor_pool: DescriptorPool,
-        descriptor_set_count: u32,
-        p_descriptor_sets: *const DescriptorSet,
-    ) -> Result {
-        (self.free_descriptor_sets)(
-            device,
-            descriptor_pool,
-            descriptor_set_count,
-            p_descriptor_sets,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateDescriptorSets.html>"]
-    pub unsafe fn update_descriptor_sets(
-        &self,
-        device: Device,
-        descriptor_write_count: u32,
-        p_descriptor_writes: *const WriteDescriptorSet,
-        descriptor_copy_count: u32,
-        p_descriptor_copies: *const CopyDescriptorSet,
-    ) {
-        (self.update_descriptor_sets)(
-            device,
-            descriptor_write_count,
-            p_descriptor_writes,
-            descriptor_copy_count,
-            p_descriptor_copies,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateFramebuffer.html>"]
-    pub unsafe fn create_framebuffer(
-        &self,
-        device: Device,
-        p_create_info: *const FramebufferCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_framebuffer: *mut Framebuffer,
-    ) -> Result {
-        (self.create_framebuffer)(device, p_create_info, p_allocator, p_framebuffer)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyFramebuffer.html>"]
-    pub unsafe fn destroy_framebuffer(
-        &self,
-        device: Device,
-        framebuffer: Framebuffer,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_framebuffer)(device, framebuffer, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass.html>"]
-    pub unsafe fn create_render_pass(
-        &self,
-        device: Device,
-        p_create_info: *const RenderPassCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_render_pass: *mut RenderPass,
-    ) -> Result {
-        (self.create_render_pass)(device, p_create_info, p_allocator, p_render_pass)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyRenderPass.html>"]
-    pub unsafe fn destroy_render_pass(
-        &self,
-        device: Device,
-        render_pass: RenderPass,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_render_pass)(device, render_pass, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRenderAreaGranularity.html>"]
-    pub unsafe fn get_render_area_granularity(
-        &self,
-        device: Device,
-        render_pass: RenderPass,
-        p_granularity: *mut Extent2D,
-    ) {
-        (self.get_render_area_granularity)(device, render_pass, p_granularity)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateCommandPool.html>"]
-    pub unsafe fn create_command_pool(
-        &self,
-        device: Device,
-        p_create_info: *const CommandPoolCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_command_pool: *mut CommandPool,
-    ) -> Result {
-        (self.create_command_pool)(device, p_create_info, p_allocator, p_command_pool)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyCommandPool.html>"]
-    pub unsafe fn destroy_command_pool(
-        &self,
-        device: Device,
-        command_pool: CommandPool,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_command_pool)(device, command_pool, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetCommandPool.html>"]
-    pub unsafe fn reset_command_pool(
-        &self,
-        device: Device,
-        command_pool: CommandPool,
-        flags: CommandPoolResetFlags,
-    ) -> Result {
-        (self.reset_command_pool)(device, command_pool, flags)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateCommandBuffers.html>"]
-    pub unsafe fn allocate_command_buffers(
-        &self,
-        device: Device,
-        p_allocate_info: *const CommandBufferAllocateInfo,
-        p_command_buffers: *mut CommandBuffer,
-    ) -> Result {
-        (self.allocate_command_buffers)(device, p_allocate_info, p_command_buffers)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeCommandBuffers.html>"]
-    pub unsafe fn free_command_buffers(
-        &self,
-        device: Device,
-        command_pool: CommandPool,
-        command_buffer_count: u32,
-        p_command_buffers: *const CommandBuffer,
-    ) {
-        (self.free_command_buffers)(
-            device,
-            command_pool,
-            command_buffer_count,
-            p_command_buffers,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBeginCommandBuffer.html>"]
-    pub unsafe fn begin_command_buffer(
-        &self,
-        command_buffer: CommandBuffer,
-        p_begin_info: *const CommandBufferBeginInfo,
-    ) -> Result {
-        (self.begin_command_buffer)(command_buffer, p_begin_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEndCommandBuffer.html>"]
-    pub unsafe fn end_command_buffer(&self, command_buffer: CommandBuffer) -> Result {
-        (self.end_command_buffer)(command_buffer)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetCommandBuffer.html>"]
-    pub unsafe fn reset_command_buffer(
-        &self,
-        command_buffer: CommandBuffer,
-        flags: CommandBufferResetFlags,
-    ) -> Result {
-        (self.reset_command_buffer)(command_buffer, flags)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindPipeline.html>"]
-    pub unsafe fn cmd_bind_pipeline(
-        &self,
-        command_buffer: CommandBuffer,
-        pipeline_bind_point: PipelineBindPoint,
-        pipeline: Pipeline,
-    ) {
-        (self.cmd_bind_pipeline)(command_buffer, pipeline_bind_point, pipeline)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetViewport.html>"]
-    pub unsafe fn cmd_set_viewport(
-        &self,
-        command_buffer: CommandBuffer,
-        first_viewport: u32,
-        viewport_count: u32,
-        p_viewports: *const Viewport,
-    ) {
-        (self.cmd_set_viewport)(command_buffer, first_viewport, viewport_count, p_viewports)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetScissor.html>"]
-    pub unsafe fn cmd_set_scissor(
-        &self,
-        command_buffer: CommandBuffer,
-        first_scissor: u32,
-        scissor_count: u32,
-        p_scissors: *const Rect2D,
-    ) {
-        (self.cmd_set_scissor)(command_buffer, first_scissor, scissor_count, p_scissors)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetLineWidth.html>"]
-    pub unsafe fn cmd_set_line_width(&self, command_buffer: CommandBuffer, line_width: f32) {
-        (self.cmd_set_line_width)(command_buffer, line_width)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBias.html>"]
-    pub unsafe fn cmd_set_depth_bias(
-        &self,
-        command_buffer: CommandBuffer,
-        depth_bias_constant_factor: f32,
-        depth_bias_clamp: f32,
-        depth_bias_slope_factor: f32,
-    ) {
-        (self.cmd_set_depth_bias)(
-            command_buffer,
-            depth_bias_constant_factor,
-            depth_bias_clamp,
-            depth_bias_slope_factor,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetBlendConstants.html>"]
-    pub unsafe fn cmd_set_blend_constants(
-        &self,
-        command_buffer: CommandBuffer,
-        blend_constants: *const [f32; 4],
-    ) {
-        (self.cmd_set_blend_constants)(command_buffer, blend_constants)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBounds.html>"]
-    pub unsafe fn cmd_set_depth_bounds(
-        &self,
-        command_buffer: CommandBuffer,
-        min_depth_bounds: f32,
-        max_depth_bounds: f32,
-    ) {
-        (self.cmd_set_depth_bounds)(command_buffer, min_depth_bounds, max_depth_bounds)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilCompareMask.html>"]
-    pub unsafe fn cmd_set_stencil_compare_mask(
-        &self,
-        command_buffer: CommandBuffer,
-        face_mask: StencilFaceFlags,
-        compare_mask: u32,
-    ) {
-        (self.cmd_set_stencil_compare_mask)(command_buffer, face_mask, compare_mask)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilWriteMask.html>"]
-    pub unsafe fn cmd_set_stencil_write_mask(
-        &self,
-        command_buffer: CommandBuffer,
-        face_mask: StencilFaceFlags,
-        write_mask: u32,
-    ) {
-        (self.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilReference.html>"]
-    pub unsafe fn cmd_set_stencil_reference(
-        &self,
-        command_buffer: CommandBuffer,
-        face_mask: StencilFaceFlags,
-        reference: u32,
-    ) {
-        (self.cmd_set_stencil_reference)(command_buffer, face_mask, reference)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindDescriptorSets.html>"]
-    pub unsafe fn cmd_bind_descriptor_sets(
-        &self,
-        command_buffer: CommandBuffer,
-        pipeline_bind_point: PipelineBindPoint,
-        layout: PipelineLayout,
-        first_set: u32,
-        descriptor_set_count: u32,
-        p_descriptor_sets: *const DescriptorSet,
-        dynamic_offset_count: u32,
-        p_dynamic_offsets: *const u32,
-    ) {
-        (self.cmd_bind_descriptor_sets)(
-            command_buffer,
-            pipeline_bind_point,
-            layout,
-            first_set,
-            descriptor_set_count,
-            p_descriptor_sets,
-            dynamic_offset_count,
-            p_dynamic_offsets,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindIndexBuffer.html>"]
-    pub unsafe fn cmd_bind_index_buffer(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        index_type: IndexType,
-    ) {
-        (self.cmd_bind_index_buffer)(command_buffer, buffer, offset, index_type)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindVertexBuffers.html>"]
-    pub unsafe fn cmd_bind_vertex_buffers(
-        &self,
-        command_buffer: CommandBuffer,
-        first_binding: u32,
-        binding_count: u32,
-        p_buffers: *const Buffer,
-        p_offsets: *const DeviceSize,
-    ) {
-        (self.cmd_bind_vertex_buffers)(
-            command_buffer,
-            first_binding,
-            binding_count,
-            p_buffers,
-            p_offsets,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDraw.html>"]
-    pub unsafe fn cmd_draw(
-        &self,
-        command_buffer: CommandBuffer,
-        vertex_count: u32,
-        instance_count: u32,
-        first_vertex: u32,
-        first_instance: u32,
-    ) {
-        (self.cmd_draw)(
-            command_buffer,
-            vertex_count,
-            instance_count,
-            first_vertex,
-            first_instance,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexed.html>"]
-    pub unsafe fn cmd_draw_indexed(
-        &self,
-        command_buffer: CommandBuffer,
-        index_count: u32,
-        instance_count: u32,
-        first_index: u32,
-        vertex_offset: i32,
-        first_instance: u32,
-    ) {
-        (self.cmd_draw_indexed)(
-            command_buffer,
-            index_count,
-            instance_count,
-            first_index,
-            vertex_offset,
-            first_instance,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirect.html>"]
-    pub unsafe fn cmd_draw_indirect(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_indirect)(command_buffer, buffer, offset, draw_count, stride)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirect.html>"]
-    pub unsafe fn cmd_draw_indexed_indirect(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_indexed_indirect)(command_buffer, buffer, offset, draw_count, stride)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatch.html>"]
-    pub unsafe fn cmd_dispatch(
-        &self,
-        command_buffer: CommandBuffer,
-        group_count_x: u32,
-        group_count_y: u32,
-        group_count_z: u32,
-    ) {
-        (self.cmd_dispatch)(command_buffer, group_count_x, group_count_y, group_count_z)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatchIndirect.html>"]
-    pub unsafe fn cmd_dispatch_indirect(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-    ) {
-        (self.cmd_dispatch_indirect)(command_buffer, buffer, offset)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBuffer.html>"]
-    pub unsafe fn cmd_copy_buffer(
-        &self,
-        command_buffer: CommandBuffer,
-        src_buffer: Buffer,
-        dst_buffer: Buffer,
-        region_count: u32,
-        p_regions: *const BufferCopy,
-    ) {
-        (self.cmd_copy_buffer)(
-            command_buffer,
-            src_buffer,
-            dst_buffer,
-            region_count,
-            p_regions,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImage.html>"]
-    pub unsafe fn cmd_copy_image(
-        &self,
-        command_buffer: CommandBuffer,
-        src_image: Image,
-        src_image_layout: ImageLayout,
-        dst_image: Image,
-        dst_image_layout: ImageLayout,
-        region_count: u32,
-        p_regions: *const ImageCopy,
-    ) {
-        (self.cmd_copy_image)(
-            command_buffer,
-            src_image,
-            src_image_layout,
-            dst_image,
-            dst_image_layout,
-            region_count,
-            p_regions,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBlitImage.html>"]
-    pub unsafe fn cmd_blit_image(
-        &self,
-        command_buffer: CommandBuffer,
-        src_image: Image,
-        src_image_layout: ImageLayout,
-        dst_image: Image,
-        dst_image_layout: ImageLayout,
-        region_count: u32,
-        p_regions: *const ImageBlit,
-        filter: Filter,
-    ) {
-        (self.cmd_blit_image)(
-            command_buffer,
-            src_image,
-            src_image_layout,
-            dst_image,
-            dst_image_layout,
-            region_count,
-            p_regions,
-            filter,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBufferToImage.html>"]
-    pub unsafe fn cmd_copy_buffer_to_image(
-        &self,
-        command_buffer: CommandBuffer,
-        src_buffer: Buffer,
-        dst_image: Image,
-        dst_image_layout: ImageLayout,
-        region_count: u32,
-        p_regions: *const BufferImageCopy,
-    ) {
-        (self.cmd_copy_buffer_to_image)(
-            command_buffer,
-            src_buffer,
-            dst_image,
-            dst_image_layout,
-            region_count,
-            p_regions,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImageToBuffer.html>"]
-    pub unsafe fn cmd_copy_image_to_buffer(
-        &self,
-        command_buffer: CommandBuffer,
-        src_image: Image,
-        src_image_layout: ImageLayout,
-        dst_buffer: Buffer,
-        region_count: u32,
-        p_regions: *const BufferImageCopy,
-    ) {
-        (self.cmd_copy_image_to_buffer)(
-            command_buffer,
-            src_image,
-            src_image_layout,
-            dst_buffer,
-            region_count,
-            p_regions,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdUpdateBuffer.html>"]
-    pub unsafe fn cmd_update_buffer(
-        &self,
-        command_buffer: CommandBuffer,
-        dst_buffer: Buffer,
-        dst_offset: DeviceSize,
-        data_size: DeviceSize,
-        p_data: *const c_void,
-    ) {
-        (self.cmd_update_buffer)(command_buffer, dst_buffer, dst_offset, data_size, p_data)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdFillBuffer.html>"]
-    pub unsafe fn cmd_fill_buffer(
-        &self,
-        command_buffer: CommandBuffer,
-        dst_buffer: Buffer,
-        dst_offset: DeviceSize,
-        size: DeviceSize,
-        data: u32,
-    ) {
-        (self.cmd_fill_buffer)(command_buffer, dst_buffer, dst_offset, size, data)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearColorImage.html>"]
-    pub unsafe fn cmd_clear_color_image(
-        &self,
-        command_buffer: CommandBuffer,
-        image: Image,
-        image_layout: ImageLayout,
-        p_color: *const ClearColorValue,
-        range_count: u32,
-        p_ranges: *const ImageSubresourceRange,
-    ) {
-        (self.cmd_clear_color_image)(
-            command_buffer,
-            image,
-            image_layout,
-            p_color,
-            range_count,
-            p_ranges,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearDepthStencilImage.html>"]
-    pub unsafe fn cmd_clear_depth_stencil_image(
-        &self,
-        command_buffer: CommandBuffer,
-        image: Image,
-        image_layout: ImageLayout,
-        p_depth_stencil: *const ClearDepthStencilValue,
-        range_count: u32,
-        p_ranges: *const ImageSubresourceRange,
-    ) {
-        (self.cmd_clear_depth_stencil_image)(
-            command_buffer,
-            image,
-            image_layout,
-            p_depth_stencil,
-            range_count,
-            p_ranges,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearAttachments.html>"]
-    pub unsafe fn cmd_clear_attachments(
-        &self,
-        command_buffer: CommandBuffer,
-        attachment_count: u32,
-        p_attachments: *const ClearAttachment,
-        rect_count: u32,
-        p_rects: *const ClearRect,
-    ) {
-        (self.cmd_clear_attachments)(
-            command_buffer,
-            attachment_count,
-            p_attachments,
-            rect_count,
-            p_rects,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResolveImage.html>"]
-    pub unsafe fn cmd_resolve_image(
-        &self,
-        command_buffer: CommandBuffer,
-        src_image: Image,
-        src_image_layout: ImageLayout,
-        dst_image: Image,
-        dst_image_layout: ImageLayout,
-        region_count: u32,
-        p_regions: *const ImageResolve,
-    ) {
-        (self.cmd_resolve_image)(
-            command_buffer,
-            src_image,
-            src_image_layout,
-            dst_image,
-            dst_image_layout,
-            region_count,
-            p_regions,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetEvent.html>"]
-    pub unsafe fn cmd_set_event(
-        &self,
-        command_buffer: CommandBuffer,
-        event: Event,
-        stage_mask: PipelineStageFlags,
-    ) {
-        (self.cmd_set_event)(command_buffer, event, stage_mask)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetEvent.html>"]
-    pub unsafe fn cmd_reset_event(
-        &self,
-        command_buffer: CommandBuffer,
-        event: Event,
-        stage_mask: PipelineStageFlags,
-    ) {
-        (self.cmd_reset_event)(command_buffer, event, stage_mask)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWaitEvents.html>"]
-    pub unsafe fn cmd_wait_events(
-        &self,
-        command_buffer: CommandBuffer,
-        event_count: u32,
-        p_events: *const Event,
-        src_stage_mask: PipelineStageFlags,
-        dst_stage_mask: PipelineStageFlags,
-        memory_barrier_count: u32,
-        p_memory_barriers: *const MemoryBarrier,
-        buffer_memory_barrier_count: u32,
-        p_buffer_memory_barriers: *const BufferMemoryBarrier,
-        image_memory_barrier_count: u32,
-        p_image_memory_barriers: *const ImageMemoryBarrier,
-    ) {
-        (self.cmd_wait_events)(
-            command_buffer,
-            event_count,
-            p_events,
-            src_stage_mask,
-            dst_stage_mask,
-            memory_barrier_count,
-            p_memory_barriers,
-            buffer_memory_barrier_count,
-            p_buffer_memory_barriers,
-            image_memory_barrier_count,
-            p_image_memory_barriers,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPipelineBarrier.html>"]
-    pub unsafe fn cmd_pipeline_barrier(
-        &self,
-        command_buffer: CommandBuffer,
-        src_stage_mask: PipelineStageFlags,
-        dst_stage_mask: PipelineStageFlags,
-        dependency_flags: DependencyFlags,
-        memory_barrier_count: u32,
-        p_memory_barriers: *const MemoryBarrier,
-        buffer_memory_barrier_count: u32,
-        p_buffer_memory_barriers: *const BufferMemoryBarrier,
-        image_memory_barrier_count: u32,
-        p_image_memory_barriers: *const ImageMemoryBarrier,
-    ) {
-        (self.cmd_pipeline_barrier)(
-            command_buffer,
-            src_stage_mask,
-            dst_stage_mask,
-            dependency_flags,
-            memory_barrier_count,
-            p_memory_barriers,
-            buffer_memory_barrier_count,
-            p_buffer_memory_barriers,
-            image_memory_barrier_count,
-            p_image_memory_barriers,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginQuery.html>"]
-    pub unsafe fn cmd_begin_query(
-        &self,
-        command_buffer: CommandBuffer,
-        query_pool: QueryPool,
-        query: u32,
-        flags: QueryControlFlags,
-    ) {
-        (self.cmd_begin_query)(command_buffer, query_pool, query, flags)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndQuery.html>"]
-    pub unsafe fn cmd_end_query(
-        &self,
-        command_buffer: CommandBuffer,
-        query_pool: QueryPool,
-        query: u32,
-    ) {
-        (self.cmd_end_query)(command_buffer, query_pool, query)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetQueryPool.html>"]
-    pub unsafe fn cmd_reset_query_pool(
-        &self,
-        command_buffer: CommandBuffer,
-        query_pool: QueryPool,
-        first_query: u32,
-        query_count: u32,
-    ) {
-        (self.cmd_reset_query_pool)(command_buffer, query_pool, first_query, query_count)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html>"]
-    pub unsafe fn cmd_write_timestamp(
-        &self,
-        command_buffer: CommandBuffer,
-        pipeline_stage: PipelineStageFlags,
-        query_pool: QueryPool,
-        query: u32,
-    ) {
-        (self.cmd_write_timestamp)(command_buffer, pipeline_stage, query_pool, query)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyQueryPoolResults.html>"]
-    pub unsafe fn cmd_copy_query_pool_results(
-        &self,
-        command_buffer: CommandBuffer,
-        query_pool: QueryPool,
-        first_query: u32,
-        query_count: u32,
-        dst_buffer: Buffer,
-        dst_offset: DeviceSize,
-        stride: DeviceSize,
-        flags: QueryResultFlags,
-    ) {
-        (self.cmd_copy_query_pool_results)(
-            command_buffer,
-            query_pool,
-            first_query,
-            query_count,
-            dst_buffer,
-            dst_offset,
-            stride,
-            flags,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushConstants.html>"]
-    pub unsafe fn cmd_push_constants(
-        &self,
-        command_buffer: CommandBuffer,
-        layout: PipelineLayout,
-        stage_flags: ShaderStageFlags,
-        offset: u32,
-        size: u32,
-        p_values: *const c_void,
-    ) {
-        (self.cmd_push_constants)(command_buffer, layout, stage_flags, offset, size, p_values)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass.html>"]
-    pub unsafe fn cmd_begin_render_pass(
-        &self,
-        command_buffer: CommandBuffer,
-        p_render_pass_begin: *const RenderPassBeginInfo,
-        contents: SubpassContents,
-    ) {
-        (self.cmd_begin_render_pass)(command_buffer, p_render_pass_begin, contents)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass.html>"]
-    pub unsafe fn cmd_next_subpass(
-        &self,
-        command_buffer: CommandBuffer,
-        contents: SubpassContents,
-    ) {
-        (self.cmd_next_subpass)(command_buffer, contents)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass.html>"]
-    pub unsafe fn cmd_end_render_pass(&self, command_buffer: CommandBuffer) {
-        (self.cmd_end_render_pass)(command_buffer)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdExecuteCommands.html>"]
-    pub unsafe fn cmd_execute_commands(
-        &self,
-        command_buffer: CommandBuffer,
-        command_buffer_count: u32,
-        p_command_buffers: *const CommandBuffer,
-    ) {
-        (self.cmd_execute_commands)(command_buffer, command_buffer_count, p_command_buffers)
-    }
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkEnumerateInstanceVersion =
@@ -5163,7 +3658,7 @@ impl EntryFnV1_1 {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        EntryFnV1_1 {
+        Self {
             enumerate_instance_version: unsafe {
                 unsafe extern "system" fn enumerate_instance_version(
                     _p_api_version: *mut u32,
@@ -5185,10 +3680,6 @@ impl EntryFnV1_1 {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceVersion.html>"]
-    pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut u32) -> Result {
-        (self.enumerate_instance_version)(p_api_version)
-    }
 }
 #[derive(Clone)]
 pub struct InstanceFnV1_1 {
@@ -5217,7 +3708,7 @@ impl InstanceFnV1_1 {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        InstanceFnV1_1 {
+        Self {
             enumerate_physical_device_groups: unsafe {
                 unsafe extern "system" fn enumerate_physical_device_groups(
                     _instance: Instance,
@@ -5449,132 +3940,6 @@ impl InstanceFnV1_1 {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDeviceGroups.html>"]
-    pub unsafe fn enumerate_physical_device_groups(
-        &self,
-        instance: Instance,
-        p_physical_device_group_count: *mut u32,
-        p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
-    ) -> Result {
-        (self.enumerate_physical_device_groups)(
-            instance,
-            p_physical_device_group_count,
-            p_physical_device_group_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures2.html>"]
-    pub unsafe fn get_physical_device_features2(
-        &self,
-        physical_device: PhysicalDevice,
-        p_features: *mut PhysicalDeviceFeatures2,
-    ) {
-        (self.get_physical_device_features2)(physical_device, p_features)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties2.html>"]
-    pub unsafe fn get_physical_device_properties2(
-        &self,
-        physical_device: PhysicalDevice,
-        p_properties: *mut PhysicalDeviceProperties2,
-    ) {
-        (self.get_physical_device_properties2)(physical_device, p_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties2.html>"]
-    pub unsafe fn get_physical_device_format_properties2(
-        &self,
-        physical_device: PhysicalDevice,
-        format: Format,
-        p_format_properties: *mut FormatProperties2,
-    ) {
-        (self.get_physical_device_format_properties2)(physical_device, format, p_format_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2.html>"]
-    pub unsafe fn get_physical_device_image_format_properties2(
-        &self,
-        physical_device: PhysicalDevice,
-        p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
-        p_image_format_properties: *mut ImageFormatProperties2,
-    ) -> Result {
-        (self.get_physical_device_image_format_properties2)(
-            physical_device,
-            p_image_format_info,
-            p_image_format_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html>"]
-    pub unsafe fn get_physical_device_queue_family_properties2(
-        &self,
-        physical_device: PhysicalDevice,
-        p_queue_family_property_count: *mut u32,
-        p_queue_family_properties: *mut QueueFamilyProperties2,
-    ) {
-        (self.get_physical_device_queue_family_properties2)(
-            physical_device,
-            p_queue_family_property_count,
-            p_queue_family_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2.html>"]
-    pub unsafe fn get_physical_device_memory_properties2(
-        &self,
-        physical_device: PhysicalDevice,
-        p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
-    ) {
-        (self.get_physical_device_memory_properties2)(physical_device, p_memory_properties)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html>"]
-    pub unsafe fn get_physical_device_sparse_image_format_properties2(
-        &self,
-        physical_device: PhysicalDevice,
-        p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
-        p_property_count: *mut u32,
-        p_properties: *mut SparseImageFormatProperties2,
-    ) {
-        (self.get_physical_device_sparse_image_format_properties2)(
-            physical_device,
-            p_format_info,
-            p_property_count,
-            p_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalBufferProperties.html>"]
-    pub unsafe fn get_physical_device_external_buffer_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
-        p_external_buffer_properties: *mut ExternalBufferProperties,
-    ) {
-        (self.get_physical_device_external_buffer_properties)(
-            physical_device,
-            p_external_buffer_info,
-            p_external_buffer_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalFenceProperties.html>"]
-    pub unsafe fn get_physical_device_external_fence_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
-        p_external_fence_properties: *mut ExternalFenceProperties,
-    ) {
-        (self.get_physical_device_external_fence_properties)(
-            physical_device,
-            p_external_fence_info,
-            p_external_fence_properties,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html>"]
-    pub unsafe fn get_physical_device_external_semaphore_properties(
-        &self,
-        physical_device: PhysicalDevice,
-        p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
-        p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
-    ) {
-        (self.get_physical_device_external_semaphore_properties)(
-            physical_device,
-            p_external_semaphore_info,
-            p_external_semaphore_properties,
-        )
-    }
 }
 #[allow(non_camel_case_types)]
 pub type PFN_vkGetDeviceQueue2 = unsafe extern "system" fn(
@@ -5608,7 +3973,7 @@ impl DeviceFnV1_1 {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        DeviceFnV1_1 {
+        Self {
             bind_buffer_memory2: unsafe {
                 unsafe extern "system" fn bind_buffer_memory2(
                     _device: Device,
@@ -5929,189 +4294,6 @@ impl DeviceFnV1_1 {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindBufferMemory2.html>"]
-    pub unsafe fn bind_buffer_memory2(
-        &self,
-        device: Device,
-        bind_info_count: u32,
-        p_bind_infos: *const BindBufferMemoryInfo,
-    ) -> Result {
-        (self.bind_buffer_memory2)(device, bind_info_count, p_bind_infos)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindImageMemory2.html>"]
-    pub unsafe fn bind_image_memory2(
-        &self,
-        device: Device,
-        bind_info_count: u32,
-        p_bind_infos: *const BindImageMemoryInfo,
-    ) -> Result {
-        (self.bind_image_memory2)(device, bind_info_count, p_bind_infos)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupPeerMemoryFeatures.html>"]
-    pub unsafe fn get_device_group_peer_memory_features(
-        &self,
-        device: Device,
-        heap_index: u32,
-        local_device_index: u32,
-        remote_device_index: u32,
-        p_peer_memory_features: *mut PeerMemoryFeatureFlags,
-    ) {
-        (self.get_device_group_peer_memory_features)(
-            device,
-            heap_index,
-            local_device_index,
-            remote_device_index,
-            p_peer_memory_features,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDeviceMask.html>"]
-    pub unsafe fn cmd_set_device_mask(&self, command_buffer: CommandBuffer, device_mask: u32) {
-        (self.cmd_set_device_mask)(command_buffer, device_mask)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatchBase.html>"]
-    pub unsafe fn cmd_dispatch_base(
-        &self,
-        command_buffer: 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,
-    ) {
-        (self.cmd_dispatch_base)(
-            command_buffer,
-            base_group_x,
-            base_group_y,
-            base_group_z,
-            group_count_x,
-            group_count_y,
-            group_count_z,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements2.html>"]
-    pub unsafe fn get_image_memory_requirements2(
-        &self,
-        device: Device,
-        p_info: *const ImageMemoryRequirementsInfo2,
-        p_memory_requirements: *mut MemoryRequirements2,
-    ) {
-        (self.get_image_memory_requirements2)(device, p_info, p_memory_requirements)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements2.html>"]
-    pub unsafe fn get_buffer_memory_requirements2(
-        &self,
-        device: Device,
-        p_info: *const BufferMemoryRequirementsInfo2,
-        p_memory_requirements: *mut MemoryRequirements2,
-    ) {
-        (self.get_buffer_memory_requirements2)(device, p_info, p_memory_requirements)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements2.html>"]
-    pub unsafe fn get_image_sparse_memory_requirements2(
-        &self,
-        device: Device,
-        p_info: *const ImageSparseMemoryRequirementsInfo2,
-        p_sparse_memory_requirement_count: *mut u32,
-        p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
-    ) {
-        (self.get_image_sparse_memory_requirements2)(
-            device,
-            p_info,
-            p_sparse_memory_requirement_count,
-            p_sparse_memory_requirements,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkTrimCommandPool.html>"]
-    pub unsafe fn trim_command_pool(
-        &self,
-        device: Device,
-        command_pool: CommandPool,
-        flags: CommandPoolTrimFlags,
-    ) {
-        (self.trim_command_pool)(device, command_pool, flags)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceQueue2.html>"]
-    pub unsafe fn get_device_queue2(
-        &self,
-        device: Device,
-        p_queue_info: *const DeviceQueueInfo2,
-        p_queue: *mut Queue,
-    ) {
-        (self.get_device_queue2)(device, p_queue_info, p_queue)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSamplerYcbcrConversion.html>"]
-    pub unsafe fn create_sampler_ycbcr_conversion(
-        &self,
-        device: Device,
-        p_create_info: *const SamplerYcbcrConversionCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_ycbcr_conversion: *mut SamplerYcbcrConversion,
-    ) -> Result {
-        (self.create_sampler_ycbcr_conversion)(
-            device,
-            p_create_info,
-            p_allocator,
-            p_ycbcr_conversion,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySamplerYcbcrConversion.html>"]
-    pub unsafe fn destroy_sampler_ycbcr_conversion(
-        &self,
-        device: Device,
-        ycbcr_conversion: SamplerYcbcrConversion,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_sampler_ycbcr_conversion)(device, ycbcr_conversion, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorUpdateTemplate.html>"]
-    pub unsafe fn create_descriptor_update_template(
-        &self,
-        device: Device,
-        p_create_info: *const DescriptorUpdateTemplateCreateInfo,
-        p_allocator: *const AllocationCallbacks,
-        p_descriptor_update_template: *mut DescriptorUpdateTemplate,
-    ) -> Result {
-        (self.create_descriptor_update_template)(
-            device,
-            p_create_info,
-            p_allocator,
-            p_descriptor_update_template,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorUpdateTemplate.html>"]
-    pub unsafe fn destroy_descriptor_update_template(
-        &self,
-        device: Device,
-        descriptor_update_template: DescriptorUpdateTemplate,
-        p_allocator: *const AllocationCallbacks,
-    ) {
-        (self.destroy_descriptor_update_template)(device, descriptor_update_template, p_allocator)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateDescriptorSetWithTemplate.html>"]
-    pub unsafe fn update_descriptor_set_with_template(
-        &self,
-        device: Device,
-        descriptor_set: DescriptorSet,
-        descriptor_update_template: DescriptorUpdateTemplate,
-        p_data: *const c_void,
-    ) {
-        (self.update_descriptor_set_with_template)(
-            device,
-            descriptor_set,
-            descriptor_update_template,
-            p_data,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDescriptorSetLayoutSupport.html>"]
-    pub unsafe fn get_descriptor_set_layout_support(
-        &self,
-        device: Device,
-        p_create_info: *const DescriptorSetLayoutCreateInfo,
-        p_support: *mut DescriptorSetLayoutSupport,
-    ) {
-        (self.get_descriptor_set_layout_support)(device, p_create_info, p_support)
-    }
 }
 #[derive(Clone)]
 pub struct EntryFnV1_2 {}
@@ -6122,7 +4304,7 @@ impl EntryFnV1_2 {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        EntryFnV1_2 {}
+        Self {}
     }
 }
 #[derive(Clone)]
@@ -6134,7 +4316,7 @@ impl InstanceFnV1_2 {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        InstanceFnV1_2 {}
+        Self {}
     }
 }
 #[derive(Clone)]
@@ -6161,7 +4343,7 @@ impl DeviceFnV1_2 {
     where
         F: FnMut(&::std::ffi::CStr) -> *const c_void,
     {
-        DeviceFnV1_2 {
+        Self {
             cmd_draw_indirect_count: unsafe {
                 unsafe extern "system" fn cmd_draw_indirect_count(
                     _command_buffer: CommandBuffer,
@@ -6411,142 +4593,761 @@ impl DeviceFnV1_2 {
             },
         }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirectCount.html>"]
-    pub unsafe fn cmd_draw_indirect_count(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        count_buffer: Buffer,
-        count_buffer_offset: DeviceSize,
-        max_draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_indirect_count)(
-            command_buffer,
-            buffer,
-            offset,
-            count_buffer,
-            count_buffer_offset,
-            max_draw_count,
-            stride,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirectCount.html>"]
-    pub unsafe fn cmd_draw_indexed_indirect_count(
-        &self,
-        command_buffer: CommandBuffer,
-        buffer: Buffer,
-        offset: DeviceSize,
-        count_buffer: Buffer,
-        count_buffer_offset: DeviceSize,
-        max_draw_count: u32,
-        stride: u32,
-    ) {
-        (self.cmd_draw_indexed_indirect_count)(
-            command_buffer,
-            buffer,
-            offset,
-            count_buffer,
-            count_buffer_offset,
-            max_draw_count,
-            stride,
-        )
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass2.html>"]
-    pub unsafe fn create_render_pass2(
-        &self,
-        device: Device,
-        p_create_info: *const RenderPassCreateInfo2,
-        p_allocator: *const AllocationCallbacks,
-        p_render_pass: *mut RenderPass,
-    ) -> Result {
-        (self.create_render_pass2)(device, p_create_info, p_allocator, p_render_pass)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass2.html>"]
-    pub unsafe fn cmd_begin_render_pass2(
-        &self,
-        command_buffer: CommandBuffer,
-        p_render_pass_begin: *const RenderPassBeginInfo,
-        p_subpass_begin_info: *const SubpassBeginInfo,
-    ) {
-        (self.cmd_begin_render_pass2)(command_buffer, p_render_pass_begin, p_subpass_begin_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass2.html>"]
-    pub unsafe fn cmd_next_subpass2(
-        &self,
-        command_buffer: CommandBuffer,
-        p_subpass_begin_info: *const SubpassBeginInfo,
-        p_subpass_end_info: *const SubpassEndInfo,
-    ) {
-        (self.cmd_next_subpass2)(command_buffer, p_subpass_begin_info, p_subpass_end_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass2.html>"]
-    pub unsafe fn cmd_end_render_pass2(
-        &self,
-        command_buffer: CommandBuffer,
-        p_subpass_end_info: *const SubpassEndInfo,
-    ) {
-        (self.cmd_end_render_pass2)(command_buffer, p_subpass_end_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetQueryPool.html>"]
-    pub unsafe fn reset_query_pool(
-        &self,
-        device: Device,
-        query_pool: QueryPool,
-        first_query: u32,
-        query_count: u32,
-    ) {
-        (self.reset_query_pool)(device, query_pool, first_query, query_count)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreCounterValue.html>"]
-    pub unsafe fn get_semaphore_counter_value(
-        &self,
-        device: Device,
-        semaphore: Semaphore,
-        p_value: *mut u64,
-    ) -> Result {
-        (self.get_semaphore_counter_value)(device, semaphore, p_value)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitSemaphores.html>"]
-    pub unsafe fn wait_semaphores(
-        &self,
-        device: Device,
-        p_wait_info: *const SemaphoreWaitInfo,
-        timeout: u64,
-    ) -> Result {
-        (self.wait_semaphores)(device, p_wait_info, timeout)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSignalSemaphore.html>"]
-    pub unsafe fn signal_semaphore(
-        &self,
-        device: Device,
-        p_signal_info: *const SemaphoreSignalInfo,
-    ) -> Result {
-        (self.signal_semaphore)(device, p_signal_info)
-    }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferDeviceAddress.html>"]
-    pub unsafe fn get_buffer_device_address(
-        &self,
-        device: Device,
-        p_info: *const BufferDeviceAddressInfo,
-    ) -> DeviceAddress {
-        (self.get_buffer_device_address)(device, p_info)
+}
+#[derive(Clone)]
+pub struct EntryFnV1_3 {}
+unsafe impl Send for EntryFnV1_3 {}
+unsafe impl Sync for EntryFnV1_3 {}
+impl EntryFnV1_3 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferOpaqueCaptureAddress.html>"]
-    pub unsafe fn get_buffer_opaque_capture_address(
-        &self,
-        device: Device,
-        p_info: *const BufferDeviceAddressInfo,
-    ) -> u64 {
-        (self.get_buffer_opaque_capture_address)(device, p_info)
+}
+#[derive(Clone)]
+pub struct InstanceFnV1_3 {
+    pub get_physical_device_tool_properties: crate::vk::PFN_vkGetPhysicalDeviceToolProperties,
+}
+unsafe impl Send for InstanceFnV1_3 {}
+unsafe impl Sync for InstanceFnV1_3 {}
+impl InstanceFnV1_3 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            get_physical_device_tool_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_tool_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_tool_count: *mut u32,
+                    _p_tool_properties: *mut PhysicalDeviceToolProperties,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_tool_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceToolProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_tool_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
-    #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html>"]
-    pub unsafe fn get_device_memory_opaque_capture_address(
-        &self,
-        device: Device,
-        p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
-    ) -> u64 {
-        (self.get_device_memory_opaque_capture_address)(device, p_info)
+}
+#[derive(Clone)]
+pub struct DeviceFnV1_3 {
+    pub create_private_data_slot: crate::vk::PFN_vkCreatePrivateDataSlot,
+    pub destroy_private_data_slot: crate::vk::PFN_vkDestroyPrivateDataSlot,
+    pub set_private_data: crate::vk::PFN_vkSetPrivateData,
+    pub get_private_data: crate::vk::PFN_vkGetPrivateData,
+    pub cmd_set_event2: crate::vk::PFN_vkCmdSetEvent2,
+    pub cmd_reset_event2: crate::vk::PFN_vkCmdResetEvent2,
+    pub cmd_wait_events2: crate::vk::PFN_vkCmdWaitEvents2,
+    pub cmd_pipeline_barrier2: crate::vk::PFN_vkCmdPipelineBarrier2,
+    pub cmd_write_timestamp2: crate::vk::PFN_vkCmdWriteTimestamp2,
+    pub queue_submit2: crate::vk::PFN_vkQueueSubmit2,
+    pub cmd_copy_buffer2: crate::vk::PFN_vkCmdCopyBuffer2,
+    pub cmd_copy_image2: crate::vk::PFN_vkCmdCopyImage2,
+    pub cmd_copy_buffer_to_image2: crate::vk::PFN_vkCmdCopyBufferToImage2,
+    pub cmd_copy_image_to_buffer2: crate::vk::PFN_vkCmdCopyImageToBuffer2,
+    pub cmd_blit_image2: crate::vk::PFN_vkCmdBlitImage2,
+    pub cmd_resolve_image2: crate::vk::PFN_vkCmdResolveImage2,
+    pub cmd_begin_rendering: crate::vk::PFN_vkCmdBeginRendering,
+    pub cmd_end_rendering: crate::vk::PFN_vkCmdEndRendering,
+    pub cmd_set_cull_mode: crate::vk::PFN_vkCmdSetCullMode,
+    pub cmd_set_front_face: crate::vk::PFN_vkCmdSetFrontFace,
+    pub cmd_set_primitive_topology: crate::vk::PFN_vkCmdSetPrimitiveTopology,
+    pub cmd_set_viewport_with_count: crate::vk::PFN_vkCmdSetViewportWithCount,
+    pub cmd_set_scissor_with_count: crate::vk::PFN_vkCmdSetScissorWithCount,
+    pub cmd_bind_vertex_buffers2: crate::vk::PFN_vkCmdBindVertexBuffers2,
+    pub cmd_set_depth_test_enable: crate::vk::PFN_vkCmdSetDepthTestEnable,
+    pub cmd_set_depth_write_enable: crate::vk::PFN_vkCmdSetDepthWriteEnable,
+    pub cmd_set_depth_compare_op: crate::vk::PFN_vkCmdSetDepthCompareOp,
+    pub cmd_set_depth_bounds_test_enable: crate::vk::PFN_vkCmdSetDepthBoundsTestEnable,
+    pub cmd_set_stencil_test_enable: crate::vk::PFN_vkCmdSetStencilTestEnable,
+    pub cmd_set_stencil_op: crate::vk::PFN_vkCmdSetStencilOp,
+    pub cmd_set_rasterizer_discard_enable: crate::vk::PFN_vkCmdSetRasterizerDiscardEnable,
+    pub cmd_set_depth_bias_enable: crate::vk::PFN_vkCmdSetDepthBiasEnable,
+    pub cmd_set_primitive_restart_enable: crate::vk::PFN_vkCmdSetPrimitiveRestartEnable,
+    pub get_device_buffer_memory_requirements: crate::vk::PFN_vkGetDeviceBufferMemoryRequirements,
+    pub get_device_image_memory_requirements: crate::vk::PFN_vkGetDeviceImageMemoryRequirements,
+    pub get_device_image_sparse_memory_requirements:
+        crate::vk::PFN_vkGetDeviceImageSparseMemoryRequirements,
+}
+unsafe impl Send for DeviceFnV1_3 {}
+unsafe impl Sync for DeviceFnV1_3 {}
+impl DeviceFnV1_3 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            create_private_data_slot: unsafe {
+                unsafe extern "system" fn create_private_data_slot(
+                    _device: Device,
+                    _p_create_info: *const PrivateDataSlotCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_private_data_slot: *mut PrivateDataSlot,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_private_data_slot)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePrivateDataSlot\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_private_data_slot
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_private_data_slot: unsafe {
+                unsafe extern "system" fn destroy_private_data_slot(
+                    _device: Device,
+                    _private_data_slot: PrivateDataSlot,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_private_data_slot)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPrivateDataSlot\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_private_data_slot
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            set_private_data: unsafe {
+                unsafe extern "system" fn set_private_data(
+                    _device: Device,
+                    _object_type: ObjectType,
+                    _object_handle: u64,
+                    _private_data_slot: PrivateDataSlot,
+                    _data: u64,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(set_private_data)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateData\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    set_private_data
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_private_data: unsafe {
+                unsafe extern "system" fn get_private_data(
+                    _device: Device,
+                    _object_type: ObjectType,
+                    _object_handle: u64,
+                    _private_data_slot: PrivateDataSlot,
+                    _p_data: *mut u64,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(get_private_data)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateData\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_private_data
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_event2: unsafe {
+                unsafe extern "system" fn cmd_set_event2(
+                    _command_buffer: CommandBuffer,
+                    _event: Event,
+                    _p_dependency_info: *const DependencyInfo,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_event2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_event2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_reset_event2: unsafe {
+                unsafe extern "system" fn cmd_reset_event2(
+                    _command_buffer: CommandBuffer,
+                    _event: Event,
+                    _stage_mask: PipelineStageFlags2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_reset_event2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_reset_event2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_wait_events2: unsafe {
+                unsafe extern "system" fn cmd_wait_events2(
+                    _command_buffer: CommandBuffer,
+                    _event_count: u32,
+                    _p_events: *const Event,
+                    _p_dependency_infos: *const DependencyInfo,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_wait_events2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_wait_events2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_pipeline_barrier2: unsafe {
+                unsafe extern "system" fn cmd_pipeline_barrier2(
+                    _command_buffer: CommandBuffer,
+                    _p_dependency_info: *const DependencyInfo,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_pipeline_barrier2)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_pipeline_barrier2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_write_timestamp2: unsafe {
+                unsafe extern "system" fn cmd_write_timestamp2(
+                    _command_buffer: CommandBuffer,
+                    _stage: PipelineStageFlags2,
+                    _query_pool: QueryPool,
+                    _query: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp2)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_write_timestamp2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            queue_submit2: unsafe {
+                unsafe extern "system" fn queue_submit2(
+                    _queue: Queue,
+                    _submit_count: u32,
+                    _p_submits: *const SubmitInfo2,
+                    _fence: Fence,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(queue_submit2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    queue_submit2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_buffer2: unsafe {
+                unsafe extern "system" fn cmd_copy_buffer2(
+                    _command_buffer: CommandBuffer,
+                    _p_copy_buffer_info: *const CopyBufferInfo2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_buffer2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_image2: unsafe {
+                unsafe extern "system" fn cmd_copy_image2(
+                    _command_buffer: CommandBuffer,
+                    _p_copy_image_info: *const CopyImageInfo2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_copy_image2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_image2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_buffer_to_image2: unsafe {
+                unsafe extern "system" fn cmd_copy_buffer_to_image2(
+                    _command_buffer: CommandBuffer,
+                    _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_buffer_to_image2)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_buffer_to_image2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_image_to_buffer2: unsafe {
+                unsafe extern "system" fn cmd_copy_image_to_buffer2(
+                    _command_buffer: CommandBuffer,
+                    _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_image_to_buffer2)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_image_to_buffer2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_blit_image2: unsafe {
+                unsafe extern "system" fn cmd_blit_image2(
+                    _command_buffer: CommandBuffer,
+                    _p_blit_image_info: *const BlitImageInfo2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_blit_image2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_blit_image2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_resolve_image2: unsafe {
+                unsafe extern "system" fn cmd_resolve_image2(
+                    _command_buffer: CommandBuffer,
+                    _p_resolve_image_info: *const ResolveImageInfo2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_resolve_image2)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_resolve_image2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_begin_rendering: unsafe {
+                unsafe extern "system" fn cmd_begin_rendering(
+                    _command_buffer: CommandBuffer,
+                    _p_rendering_info: *const RenderingInfo,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_begin_rendering)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRendering\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_begin_rendering
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_end_rendering: unsafe {
+                unsafe extern "system" fn cmd_end_rendering(_command_buffer: CommandBuffer) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_end_rendering)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRendering\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_end_rendering
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_cull_mode: unsafe {
+                unsafe extern "system" fn cmd_set_cull_mode(
+                    _command_buffer: CommandBuffer,
+                    _cull_mode: CullModeFlags,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_cull_mode)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullMode\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_cull_mode
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_front_face: unsafe {
+                unsafe extern "system" fn cmd_set_front_face(
+                    _command_buffer: CommandBuffer,
+                    _front_face: FrontFace,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_front_face)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFace\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_front_face
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_primitive_topology: unsafe {
+                unsafe extern "system" fn cmd_set_primitive_topology(
+                    _command_buffer: CommandBuffer,
+                    _primitive_topology: PrimitiveTopology,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_primitive_topology)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopology\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_primitive_topology
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_viewport_with_count: unsafe {
+                unsafe extern "system" fn cmd_set_viewport_with_count(
+                    _command_buffer: CommandBuffer,
+                    _viewport_count: u32,
+                    _p_viewports: *const Viewport,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_viewport_with_count)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCount\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_viewport_with_count
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_scissor_with_count: unsafe {
+                unsafe extern "system" fn cmd_set_scissor_with_count(
+                    _command_buffer: CommandBuffer,
+                    _scissor_count: u32,
+                    _p_scissors: *const Rect2D,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_scissor_with_count)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCount\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_scissor_with_count
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_vertex_buffers2: unsafe {
+                unsafe extern "system" fn cmd_bind_vertex_buffers2(
+                    _command_buffer: CommandBuffer,
+                    _first_binding: u32,
+                    _binding_count: u32,
+                    _p_buffers: *const Buffer,
+                    _p_offsets: *const DeviceSize,
+                    _p_sizes: *const DeviceSize,
+                    _p_strides: *const DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_bind_vertex_buffers2)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_vertex_buffers2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_test_enable: unsafe {
+                unsafe extern "system" fn cmd_set_depth_test_enable(
+                    _command_buffer: CommandBuffer,
+                    _depth_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_test_enable)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnable\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_test_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_write_enable: unsafe {
+                unsafe extern "system" fn cmd_set_depth_write_enable(
+                    _command_buffer: CommandBuffer,
+                    _depth_write_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_write_enable)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnable\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_write_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_compare_op: unsafe {
+                unsafe extern "system" fn cmd_set_depth_compare_op(
+                    _command_buffer: CommandBuffer,
+                    _depth_compare_op: CompareOp,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_compare_op)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOp\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_compare_op
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_bounds_test_enable: unsafe {
+                unsafe extern "system" fn cmd_set_depth_bounds_test_enable(
+                    _command_buffer: CommandBuffer,
+                    _depth_bounds_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_bounds_test_enable)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthBoundsTestEnable\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_bounds_test_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_stencil_test_enable: unsafe {
+                unsafe extern "system" fn cmd_set_stencil_test_enable(
+                    _command_buffer: CommandBuffer,
+                    _stencil_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_stencil_test_enable)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnable\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_stencil_test_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_stencil_op: unsafe {
+                unsafe extern "system" fn cmd_set_stencil_op(
+                    _command_buffer: CommandBuffer,
+                    _face_mask: StencilFaceFlags,
+                    _fail_op: StencilOp,
+                    _pass_op: StencilOp,
+                    _depth_fail_op: StencilOp,
+                    _compare_op: CompareOp,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_stencil_op)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOp\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_stencil_op
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_rasterizer_discard_enable: unsafe {
+                unsafe extern "system" fn cmd_set_rasterizer_discard_enable(
+                    _command_buffer: CommandBuffer,
+                    _rasterizer_discard_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_rasterizer_discard_enable)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetRasterizerDiscardEnable\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_rasterizer_discard_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_bias_enable: unsafe {
+                unsafe extern "system" fn cmd_set_depth_bias_enable(
+                    _command_buffer: CommandBuffer,
+                    _depth_bias_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_bias_enable)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnable\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_bias_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_primitive_restart_enable: unsafe {
+                unsafe extern "system" fn cmd_set_primitive_restart_enable(
+                    _command_buffer: CommandBuffer,
+                    _primitive_restart_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_primitive_restart_enable)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetPrimitiveRestartEnable\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_primitive_restart_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_buffer_memory_requirements: unsafe {
+                unsafe extern "system" fn get_device_buffer_memory_requirements(
+                    _device: Device,
+                    _p_info: *const DeviceBufferMemoryRequirements,
+                    _p_memory_requirements: *mut MemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_buffer_memory_requirements)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceBufferMemoryRequirements\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_buffer_memory_requirements
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_image_memory_requirements: unsafe {
+                unsafe extern "system" fn get_device_image_memory_requirements(
+                    _device: Device,
+                    _p_info: *const DeviceImageMemoryRequirements,
+                    _p_memory_requirements: *mut MemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_image_memory_requirements)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceImageMemoryRequirements\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_image_memory_requirements
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_image_sparse_memory_requirements: unsafe {
+                unsafe extern "system" fn get_device_image_sparse_memory_requirements(
+                    _device: Device,
+                    _p_info: *const DeviceImageMemoryRequirements,
+                    _p_sparse_memory_requirement_count: *mut u32,
+                    _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_image_sparse_memory_requirements)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceImageSparseMemoryRequirements\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_image_sparse_memory_requirements
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
     }
 }
diff --git a/src/vk/macros.rs b/src/vk/macros.rs
index cae901d..e986be3 100644
--- a/src/vk/macros.rs
+++ b/src/vk/macros.rs
@@ -1,103 +1,82 @@
 #[macro_export]
 macro_rules! vk_bitflags_wrapped {
-    ($ name : ident , $ all : expr , $ flag_type : ty) => {
+    ($ name : ident , $ flag_type : ty) => {
         impl Default for $name {
-            fn default() -> $name {
-                $name(0)
+            fn default() -> Self {
+                Self(0)
             }
         }
         impl $name {
             #[inline]
-            pub const fn empty() -> $name {
-                $name(0)
-            }
-            #[inline]
-            pub const fn all() -> $name {
-                $name($all)
+            pub const fn empty() -> Self {
+                Self(0)
             }
             #[inline]
             pub const fn from_raw(x: $flag_type) -> Self {
-                $name(x)
+                Self(x)
             }
             #[inline]
             pub const fn as_raw(self) -> $flag_type {
                 self.0
             }
             #[inline]
-            pub fn is_empty(self) -> bool {
-                self == $name::empty()
-            }
-            #[inline]
-            pub fn is_all(self) -> bool {
-                self & $name::all() == $name::all()
+            pub const fn is_empty(self) -> bool {
+                self.0 == Self::empty().0
             }
             #[inline]
-            pub fn intersects(self, other: $name) -> bool {
-                self & other != $name::empty()
+            pub const fn intersects(self, other: Self) -> bool {
+                !Self(self.0 & other.0).is_empty()
             }
             #[doc = r" Returns whether `other` is a subset of `self`"]
             #[inline]
-            pub fn contains(self, other: $name) -> bool {
-                self & other == other
+            pub const fn contains(self, other: Self) -> bool {
+                self.0 & other.0 == other.0
             }
         }
         impl ::std::ops::BitOr for $name {
-            type Output = $name;
+            type Output = Self;
             #[inline]
-            fn bitor(self, rhs: $name) -> $name {
-                $name(self.0 | rhs.0)
+            fn bitor(self, rhs: Self) -> Self {
+                Self(self.0 | rhs.0)
             }
         }
         impl ::std::ops::BitOrAssign for $name {
             #[inline]
-            fn bitor_assign(&mut self, rhs: $name) {
+            fn bitor_assign(&mut self, rhs: Self) {
                 *self = *self | rhs
             }
         }
         impl ::std::ops::BitAnd for $name {
-            type Output = $name;
+            type Output = Self;
             #[inline]
-            fn bitand(self, rhs: $name) -> $name {
-                $name(self.0 & rhs.0)
+            fn bitand(self, rhs: Self) -> Self {
+                Self(self.0 & rhs.0)
             }
         }
         impl ::std::ops::BitAndAssign for $name {
             #[inline]
-            fn bitand_assign(&mut self, rhs: $name) {
+            fn bitand_assign(&mut self, rhs: Self) {
                 *self = *self & rhs
             }
         }
         impl ::std::ops::BitXor for $name {
-            type Output = $name;
+            type Output = Self;
             #[inline]
-            fn bitxor(self, rhs: $name) -> $name {
-                $name(self.0 ^ rhs.0)
+            fn bitxor(self, rhs: Self) -> Self {
+                Self(self.0 ^ rhs.0)
             }
         }
         impl ::std::ops::BitXorAssign for $name {
             #[inline]
-            fn bitxor_assign(&mut self, rhs: $name) {
+            fn bitxor_assign(&mut self, rhs: Self) {
                 *self = *self ^ rhs
             }
         }
-        impl ::std::ops::Sub for $name {
-            type Output = $name;
-            #[inline]
-            fn sub(self, rhs: $name) -> $name {
-                self & !rhs
-            }
-        }
-        impl ::std::ops::SubAssign for $name {
-            #[inline]
-            fn sub_assign(&mut self, rhs: $name) {
-                *self = *self - rhs
-            }
-        }
         impl ::std::ops::Not for $name {
-            type Output = $name;
+            type Output = Self;
             #[inline]
-            fn not(self) -> $name {
-                self ^ $name::all()
+            fn not(self) -> Self {
+                Self(!self.0)
             }
         }
     };
@@ -115,15 +94,15 @@ macro_rules! handle_nondispatchable {
         impl Handle for $name {
             const TYPE: ObjectType = ObjectType::$ty;
             fn as_raw(self) -> u64 {
-                self.0 as u64
+                self.0
             }
             fn from_raw(x: u64) -> Self {
-                $name(x as _)
+                Self(x)
             }
         }
         impl $name {
-            pub const fn null() -> $name {
-                $name(0)
+            pub const fn null() -> Self {
+                Self(0)
             }
         }
         impl fmt::Pointer for $name {
@@ -149,8 +128,8 @@ macro_rules! define_handle {
         #[$doc_link]
         pub struct $name(*mut u8);
         impl Default for $name {
-            fn default() -> $name {
-                $name::null()
+            fn default() -> Self {
+                Self::null()
             }
         }
         impl Handle for $name {
@@ -159,14 +138,14 @@ macro_rules! define_handle {
                 self.0 as u64
             }
             fn from_raw(x: u64) -> Self {
-                $name(x as _)
+                Self(x as _)
             }
         }
         unsafe impl Send for $name {}
         unsafe impl Sync for $name {}
         impl $name {
             pub const fn null() -> Self {
-                $name(::std::ptr::null_mut())
+                Self(::std::ptr::null_mut())
             }
         }
         impl fmt::Pointer for $name {
diff --git a/src/vk/native.rs b/src/vk/native.rs
index f8d2bca..03e0ad5 100644
--- a/src/vk/native.rs
+++ b/src/vk/native.rs
@@ -1,4 +1,4 @@
-/* automatically generated by rust-bindgen 0.58.1 */
+/* automatically generated by rust-bindgen 0.64.0 */
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -80,151 +80,145 @@ where
         }
     }
 }
-pub type size_t = ::std::os::raw::c_ulong;
-pub type __int8_t = ::std::os::raw::c_schar;
-pub type __uint8_t = ::std::os::raw::c_uchar;
-pub type __int16_t = ::std::os::raw::c_short;
-pub type __uint16_t = ::std::os::raw::c_ushort;
-pub type __int32_t = ::std::os::raw::c_int;
-pub type __uint32_t = ::std::os::raw::c_uint;
-pub type __int64_t = ::std::os::raw::c_long;
-pub type __uint64_t = ::std::os::raw::c_ulong;
-pub const StdVideoH264ChromaFormatIdc_std_video_h264_chroma_format_idc_monochrome:
+pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME:
     StdVideoH264ChromaFormatIdc = 0;
-pub const StdVideoH264ChromaFormatIdc_std_video_h264_chroma_format_idc_420:
+pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_420:
     StdVideoH264ChromaFormatIdc = 1;
-pub const StdVideoH264ChromaFormatIdc_std_video_h264_chroma_format_idc_422:
+pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_422:
     StdVideoH264ChromaFormatIdc = 2;
-pub const StdVideoH264ChromaFormatIdc_std_video_h264_chroma_format_idc_444:
+pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_444:
     StdVideoH264ChromaFormatIdc = 3;
+pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID:
+    StdVideoH264ChromaFormatIdc = 2147483647;
 pub type StdVideoH264ChromaFormatIdc = ::std::os::raw::c_uint;
-pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_baseline: StdVideoH264ProfileIdc = 66;
-pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_main: StdVideoH264ProfileIdc = 77;
-pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_high: StdVideoH264ProfileIdc = 100;
-pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_high_444_predictive:
+pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_BASELINE: StdVideoH264ProfileIdc = 66;
+pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_MAIN: StdVideoH264ProfileIdc = 77;
+pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH: StdVideoH264ProfileIdc = 100;
+pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE:
     StdVideoH264ProfileIdc = 244;
-pub const StdVideoH264ProfileIdc_std_video_h264_profile_idc_invalid: StdVideoH264ProfileIdc =
+pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_INVALID: StdVideoH264ProfileIdc =
     2147483647;
 pub type StdVideoH264ProfileIdc = ::std::os::raw::c_uint;
-pub const StdVideoH264Level_std_video_h264_level_1_0: StdVideoH264Level = 0;
-pub const StdVideoH264Level_std_video_h264_level_1_1: StdVideoH264Level = 1;
-pub const StdVideoH264Level_std_video_h264_level_1_2: StdVideoH264Level = 2;
-pub const StdVideoH264Level_std_video_h264_level_1_3: StdVideoH264Level = 3;
-pub const StdVideoH264Level_std_video_h264_level_2_0: StdVideoH264Level = 4;
-pub const StdVideoH264Level_std_video_h264_level_2_1: StdVideoH264Level = 5;
-pub const StdVideoH264Level_std_video_h264_level_2_2: StdVideoH264Level = 6;
-pub const StdVideoH264Level_std_video_h264_level_3_0: StdVideoH264Level = 7;
-pub const StdVideoH264Level_std_video_h264_level_3_1: StdVideoH264Level = 8;
-pub const StdVideoH264Level_std_video_h264_level_3_2: StdVideoH264Level = 9;
-pub const StdVideoH264Level_std_video_h264_level_4_0: StdVideoH264Level = 10;
-pub const StdVideoH264Level_std_video_h264_level_4_1: StdVideoH264Level = 11;
-pub const StdVideoH264Level_std_video_h264_level_4_2: StdVideoH264Level = 12;
-pub const StdVideoH264Level_std_video_h264_level_5_0: StdVideoH264Level = 13;
-pub const StdVideoH264Level_std_video_h264_level_5_1: StdVideoH264Level = 14;
-pub const StdVideoH264Level_std_video_h264_level_5_2: StdVideoH264Level = 15;
-pub const StdVideoH264Level_std_video_h264_level_6_0: StdVideoH264Level = 16;
-pub const StdVideoH264Level_std_video_h264_level_6_1: StdVideoH264Level = 17;
-pub const StdVideoH264Level_std_video_h264_level_6_2: StdVideoH264Level = 18;
-pub const StdVideoH264Level_std_video_h264_level_invalid: StdVideoH264Level = 2147483647;
-pub type StdVideoH264Level = ::std::os::raw::c_uint;
-pub const StdVideoH264PocType_std_video_h264_poc_type_0: StdVideoH264PocType = 0;
-pub const StdVideoH264PocType_std_video_h264_poc_type_1: StdVideoH264PocType = 1;
-pub const StdVideoH264PocType_std_video_h264_poc_type_2: StdVideoH264PocType = 2;
-pub const StdVideoH264PocType_std_video_h264_poc_type_invalid: StdVideoH264PocType = 2147483647;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_0: StdVideoH264LevelIdc = 0;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_1: StdVideoH264LevelIdc = 1;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_2: StdVideoH264LevelIdc = 2;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_3: StdVideoH264LevelIdc = 3;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_0: StdVideoH264LevelIdc = 4;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_1: StdVideoH264LevelIdc = 5;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_2: StdVideoH264LevelIdc = 6;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_0: StdVideoH264LevelIdc = 7;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_1: StdVideoH264LevelIdc = 8;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_2: StdVideoH264LevelIdc = 9;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_0: StdVideoH264LevelIdc = 10;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_1: StdVideoH264LevelIdc = 11;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_2: StdVideoH264LevelIdc = 12;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_0: StdVideoH264LevelIdc = 13;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_1: StdVideoH264LevelIdc = 14;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_2: StdVideoH264LevelIdc = 15;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_0: StdVideoH264LevelIdc = 16;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_1: StdVideoH264LevelIdc = 17;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_2: StdVideoH264LevelIdc = 18;
+pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_INVALID: StdVideoH264LevelIdc = 2147483647;
+pub type StdVideoH264LevelIdc = ::std::os::raw::c_uint;
+pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_0: StdVideoH264PocType = 0;
+pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_1: StdVideoH264PocType = 1;
+pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_2: StdVideoH264PocType = 2;
+pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_INVALID: StdVideoH264PocType = 2147483647;
 pub type StdVideoH264PocType = ::std::os::raw::c_uint;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_unspecified:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED:
     StdVideoH264AspectRatioIdc = 0;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_square:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE:
     StdVideoH264AspectRatioIdc = 1;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_12_11:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11:
     StdVideoH264AspectRatioIdc = 2;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_10_11:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11:
     StdVideoH264AspectRatioIdc = 3;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_16_11:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11:
     StdVideoH264AspectRatioIdc = 4;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_40_33:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33:
     StdVideoH264AspectRatioIdc = 5;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_24_11:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11:
     StdVideoH264AspectRatioIdc = 6;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_20_11:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11:
     StdVideoH264AspectRatioIdc = 7;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_32_11:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11:
     StdVideoH264AspectRatioIdc = 8;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_80_33:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33:
     StdVideoH264AspectRatioIdc = 9;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_18_11:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11:
     StdVideoH264AspectRatioIdc = 10;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_15_11:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11:
     StdVideoH264AspectRatioIdc = 11;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_64_33:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33:
     StdVideoH264AspectRatioIdc = 12;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_160_99:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99:
     StdVideoH264AspectRatioIdc = 13;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_4_3:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3:
     StdVideoH264AspectRatioIdc = 14;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_3_2:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2:
     StdVideoH264AspectRatioIdc = 15;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_2_1:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1:
     StdVideoH264AspectRatioIdc = 16;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_extended_sar:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR:
     StdVideoH264AspectRatioIdc = 255;
-pub const StdVideoH264AspectRatioIdc_std_video_h264_aspect_ratio_idc_invalid:
+pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID:
     StdVideoH264AspectRatioIdc = 2147483647;
 pub type StdVideoH264AspectRatioIdc = ::std::os::raw::c_uint;
-pub const StdVideoH264WeightedBiPredIdc_std_video_h264_default_weighted_b_slices_prediction_idc:
-    StdVideoH264WeightedBiPredIdc = 0;
-pub const StdVideoH264WeightedBiPredIdc_std_video_h264_explicit_weighted_b_slices_prediction_idc:
-    StdVideoH264WeightedBiPredIdc = 1;
-pub const StdVideoH264WeightedBiPredIdc_std_video_h264_implicit_weighted_b_slices_prediction_idc:
-    StdVideoH264WeightedBiPredIdc = 2;
-pub const StdVideoH264WeightedBiPredIdc_std_video_h264_invalid_weighted_b_slices_prediction_idc:
-    StdVideoH264WeightedBiPredIdc = 2147483647;
-pub type StdVideoH264WeightedBiPredIdc = ::std::os::raw::c_uint;
-pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_short_term_subtract : StdVideoH264ModificationOfPicNumsIdc = 0 ;
-pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_short_term_add : StdVideoH264ModificationOfPicNumsIdc = 1 ;
-pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_long_term : StdVideoH264ModificationOfPicNumsIdc = 2 ;
-pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_end:
+pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT:
+    StdVideoH264WeightedBipredIdc = 0;
+pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT:
+    StdVideoH264WeightedBipredIdc = 1;
+pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT:
+    StdVideoH264WeightedBipredIdc = 2;
+pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID:
+    StdVideoH264WeightedBipredIdc = 2147483647;
+pub type StdVideoH264WeightedBipredIdc = ::std::os::raw::c_uint;
+pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT : StdVideoH264ModificationOfPicNumsIdc = 0 ;
+pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD : StdVideoH264ModificationOfPicNumsIdc = 1 ;
+pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM : StdVideoH264ModificationOfPicNumsIdc = 2 ;
+pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END:
     StdVideoH264ModificationOfPicNumsIdc = 3;
-pub const StdVideoH264ModificationOfPicNumsIdc_std_video_h264_modification_of_pic_nums_idc_invalid : StdVideoH264ModificationOfPicNumsIdc = 2147483647 ;
+pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID : StdVideoH264ModificationOfPicNumsIdc = 2147483647 ;
 pub type StdVideoH264ModificationOfPicNumsIdc = ::std::os::raw::c_uint;
-pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_end:
+pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END:
     StdVideoH264MemMgmtControlOp = 0;
-pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_unmark_short_term:
+pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM:
     StdVideoH264MemMgmtControlOp = 1;
-pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_unmark_long_term:
+pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM:
     StdVideoH264MemMgmtControlOp = 2;
-pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_mark_long_term:
+pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM:
     StdVideoH264MemMgmtControlOp = 3;
-pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_set_max_long_term_index : StdVideoH264MemMgmtControlOp = 4 ;
-pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_unmark_all:
+pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX : StdVideoH264MemMgmtControlOp = 4 ;
+pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL:
     StdVideoH264MemMgmtControlOp = 5;
-pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_mark_current_as_long_term : StdVideoH264MemMgmtControlOp = 6 ;
-pub const StdVideoH264MemMgmtControlOp_std_video_h264_mem_mgmt_control_op_invalid:
+pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM : StdVideoH264MemMgmtControlOp = 6 ;
+pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID:
     StdVideoH264MemMgmtControlOp = 2147483647;
 pub type StdVideoH264MemMgmtControlOp = ::std::os::raw::c_uint;
-pub const StdVideoH264CabacInitIdc_std_video_h264_cabac_init_idc_0: StdVideoH264CabacInitIdc = 0;
-pub const StdVideoH264CabacInitIdc_std_video_h264_cabac_init_idc_1: StdVideoH264CabacInitIdc = 1;
-pub const StdVideoH264CabacInitIdc_std_video_h264_cabac_init_idc_2: StdVideoH264CabacInitIdc = 2;
-pub const StdVideoH264CabacInitIdc_std_video_h264_cabac_init_idc_invalid: StdVideoH264CabacInitIdc =
+pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_0: StdVideoH264CabacInitIdc = 0;
+pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_1: StdVideoH264CabacInitIdc = 1;
+pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_2: StdVideoH264CabacInitIdc = 2;
+pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_INVALID: StdVideoH264CabacInitIdc =
     2147483647;
 pub type StdVideoH264CabacInitIdc = ::std::os::raw::c_uint;
-pub const StdVideoH264DisableDeblockingFilterIdc_std_video_h264_disable_deblocking_filter_idc_disabled : StdVideoH264DisableDeblockingFilterIdc = 0 ;
-pub const StdVideoH264DisableDeblockingFilterIdc_std_video_h264_disable_deblocking_filter_idc_enabled : StdVideoH264DisableDeblockingFilterIdc = 1 ;
-pub const StdVideoH264DisableDeblockingFilterIdc_std_video_h264_disable_deblocking_filter_idc_partial : StdVideoH264DisableDeblockingFilterIdc = 2 ;
-pub const StdVideoH264DisableDeblockingFilterIdc_std_video_h264_disable_deblocking_filter_idc_invalid : StdVideoH264DisableDeblockingFilterIdc = 2147483647 ;
+pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED : StdVideoH264DisableDeblockingFilterIdc = 0 ;
+pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED : StdVideoH264DisableDeblockingFilterIdc = 1 ;
+pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL : StdVideoH264DisableDeblockingFilterIdc = 2 ;
+pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID : StdVideoH264DisableDeblockingFilterIdc = 2147483647 ;
 pub type StdVideoH264DisableDeblockingFilterIdc = ::std::os::raw::c_uint;
-pub const StdVideoH264PictureType_std_video_h264_picture_type_i: StdVideoH264PictureType = 0;
-pub const StdVideoH264PictureType_std_video_h264_picture_type_p: StdVideoH264PictureType = 1;
-pub const StdVideoH264PictureType_std_video_h264_picture_type_b: StdVideoH264PictureType = 2;
-pub const StdVideoH264PictureType_std_video_h264_picture_type_invalid: StdVideoH264PictureType =
-    2147483647;
-pub type StdVideoH264PictureType = ::std::os::raw::c_uint;
-pub const StdVideoH264SliceType_std_video_h264_slice_type_i: StdVideoH264SliceType = 0;
-pub const StdVideoH264SliceType_std_video_h264_slice_type_p: StdVideoH264SliceType = 1;
-pub const StdVideoH264SliceType_std_video_h264_slice_type_b: StdVideoH264SliceType = 2;
-pub const StdVideoH264SliceType_std_video_h264_slice_type_invalid: StdVideoH264SliceType =
+pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_P: StdVideoH264SliceType = 0;
+pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_B: StdVideoH264SliceType = 1;
+pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_I: StdVideoH264SliceType = 2;
+pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_INVALID: StdVideoH264SliceType =
     2147483647;
 pub type StdVideoH264SliceType = ::std::os::raw::c_uint;
+pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_P: StdVideoH264PictureType = 0;
+pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_B: StdVideoH264PictureType = 1;
+pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_I: StdVideoH264PictureType = 2;
+pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_IDR: StdVideoH264PictureType = 5;
+pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_INVALID: StdVideoH264PictureType =
+    2147483647;
+pub type StdVideoH264PictureType = ::std::os::raw::c_uint;
 #[repr(C)]
 #[repr(align(4))]
 #[derive(Debug, Copy, Clone)]
@@ -464,6 +458,7 @@ pub struct StdVideoH264HrdParameters {
     pub cpb_cnt_minus1: u8,
     pub bit_rate_scale: u8,
     pub cpb_size_scale: u8,
+    pub reserved1: u8,
     pub bit_rate_value_minus1: [u32; 32usize],
     pub cpb_size_value_minus1: [u32; 32usize],
     pub cbr_flag: [u8; 32usize],
@@ -474,6 +469,9 @@ pub struct StdVideoH264HrdParameters {
 }
 #[test]
 fn bindgen_test_layout_StdVideoH264HrdParameters() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH264HrdParameters> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH264HrdParameters>(),
         308usize,
@@ -485,10 +483,7 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
         concat!("Alignment of ", stringify!(StdVideoH264HrdParameters))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>())).cpb_cnt_minus1 as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).cpb_cnt_minus1) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -498,10 +493,7 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>())).bit_rate_scale as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_scale) as usize - ptr as usize },
         1usize,
         concat!(
             "Offset of field: ",
@@ -511,10 +503,7 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>())).cpb_size_scale as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_scale) as usize - ptr as usize },
         2usize,
         concat!(
             "Offset of field: ",
@@ -524,10 +513,17 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>())).bit_rate_value_minus1 as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        3usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH264HrdParameters),
+            "::",
+            stringify!(reserved1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -537,10 +533,7 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>())).cpb_size_value_minus1 as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_value_minus1) as usize - ptr as usize },
         132usize,
         concat!(
             "Offset of field: ",
@@ -550,9 +543,7 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>())).cbr_flag as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).cbr_flag) as usize - ptr as usize },
         260usize,
         concat!(
             "Offset of field: ",
@@ -563,8 +554,8 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>()))
-                .initial_cpb_removal_delay_length_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).initial_cpb_removal_delay_length_minus1) as usize
+                - ptr as usize
         },
         292usize,
         concat!(
@@ -576,8 +567,7 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>())).cpb_removal_delay_length_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).cpb_removal_delay_length_minus1) as usize - ptr as usize
         },
         296usize,
         concat!(
@@ -589,8 +579,7 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>())).dpb_output_delay_length_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).dpb_output_delay_length_minus1) as usize - ptr as usize
         },
         300usize,
         concat!(
@@ -601,10 +590,7 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264HrdParameters>())).time_offset_length as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).time_offset_length) as usize - ptr as usize },
         304usize,
         concat!(
             "Offset of field: ",
@@ -617,67 +603,74 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() {
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH264SequenceParameterSetVui {
+    pub flags: StdVideoH264SpsVuiFlags,
     pub aspect_ratio_idc: StdVideoH264AspectRatioIdc,
     pub sar_width: u16,
     pub sar_height: u16,
     pub video_format: u8,
-    pub color_primaries: u8,
+    pub colour_primaries: u8,
     pub transfer_characteristics: u8,
     pub matrix_coefficients: u8,
     pub num_units_in_tick: u32,
     pub time_scale: u32,
-    pub hrd_parameters: StdVideoH264HrdParameters,
-    pub num_reorder_frames: u8,
+    pub max_num_reorder_frames: u8,
     pub max_dec_frame_buffering: u8,
-    pub flags: StdVideoH264SpsVuiFlags,
+    pub chroma_sample_loc_type_top_field: u8,
+    pub chroma_sample_loc_type_bottom_field: u8,
+    pub reserved1: u32,
+    pub pHrdParameters: *const StdVideoH264HrdParameters,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH264SequenceParameterSetVui> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH264SequenceParameterSetVui>(),
-        336usize,
+        40usize,
         concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSetVui))
     );
     assert_eq!(
         ::std::mem::align_of::<StdVideoH264SequenceParameterSetVui>(),
-        4usize,
+        8usize,
         concat!(
             "Alignment of ",
             stringify!(StdVideoH264SequenceParameterSetVui)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).aspect_ratio_idc
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
             "::",
-            stringify!(aspect_ratio_idc)
+            stringify!(flags)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).sar_width as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio_idc) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
             "::",
+            stringify!(aspect_ratio_idc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH264SequenceParameterSetVui),
+            "::",
             stringify!(sar_width)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).sar_height as *const _
-                as usize
-        },
-        6usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize },
+        10usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
@@ -686,11 +679,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).video_format as *const _
-                as usize
-        },
-        8usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize },
+        12usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
@@ -699,24 +689,18 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).color_primaries
-                as *const _ as usize
-        },
-        9usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize },
+        13usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
             "::",
-            stringify!(color_primaries)
+            stringify!(colour_primaries)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).transfer_characteristics
-                as *const _ as usize
-        },
-        10usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize },
+        14usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
@@ -725,11 +709,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).matrix_coefficients
-                as *const _ as usize
-        },
-        11usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).matrix_coefficients) as usize - ptr as usize },
+        15usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
@@ -738,11 +719,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).num_units_in_tick
-                as *const _ as usize
-        },
-        12usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).num_units_in_tick) as usize - ptr as usize },
+        16usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
@@ -751,11 +729,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).time_scale as *const _
-                as usize
-        },
-        16usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).time_scale) as usize - ptr as usize },
+        20usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
@@ -764,55 +739,67 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).hrd_parameters
-                as *const _ as usize
-        },
-        20usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_frames) as usize - ptr as usize },
+        24usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
             "::",
-            stringify!(hrd_parameters)
+            stringify!(max_num_reorder_frames)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).num_reorder_frames
-                as *const _ as usize
-        },
-        328usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).max_dec_frame_buffering) as usize - ptr as usize },
+        25usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
             "::",
-            stringify!(num_reorder_frames)
+            stringify!(max_dec_frame_buffering)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).max_dec_frame_buffering
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize
         },
-        329usize,
+        26usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
             "::",
-            stringify!(max_dec_frame_buffering)
+            stringify!(chroma_sample_loc_type_top_field)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSetVui>())).flags as *const _
-                as usize
+            ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize
         },
-        332usize,
+        27usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSetVui),
             "::",
-            stringify!(flags)
+            stringify!(chroma_sample_loc_type_bottom_field)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        28usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH264SequenceParameterSetVui),
+            "::",
+            stringify!(reserved1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH264SequenceParameterSetVui),
+            "::",
+            stringify!(pHrdParameters)
         )
     );
 }
@@ -821,8 +808,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() {
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH264SpsFlags {
     pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
-    pub __bindgen_padding_0: u8,
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
+    pub __bindgen_padding_0: u16,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH264SpsFlags() {
@@ -949,11 +936,11 @@ impl StdVideoH264SpsFlags {
         }
     }
     #[inline]
-    pub fn residual_colour_transform_flag(&self) -> u32 {
+    pub fn separate_colour_plane_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_residual_colour_transform_flag(&mut self, val: u32) {
+    pub fn set_separate_colour_plane_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(10usize, 1u8, val as u64)
@@ -971,58 +958,47 @@ impl StdVideoH264SpsFlags {
         }
     }
     #[inline]
-    pub fn first_picture_after_seek_flag(&self) -> u32 {
+    pub fn qpprime_y_zero_transform_bypass_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_first_picture_after_seek_flag(&mut self, val: u32) {
+    pub fn set_qpprime_y_zero_transform_bypass_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(12usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn qpprime_y_zero_transform_bypass_flag(&self) -> u32 {
+    pub fn frame_cropping_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_qpprime_y_zero_transform_bypass_flag(&mut self, val: u32) {
+    pub fn set_frame_cropping_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(13usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn frame_cropping_flag(&self) -> u32 {
+    pub fn seq_scaling_matrix_present_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_frame_cropping_flag(&mut self, val: u32) {
+    pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(14usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn scaling_matrix_present_flag(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_scaling_matrix_present_flag(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(15usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
     pub fn vui_parameters_present_flag(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
     }
     #[inline]
     pub fn set_vui_parameters_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(16usize, 1u8, val as u64)
+            self._bitfield_1.set(15usize, 1u8, val as u64)
         }
     }
     #[inline]
@@ -1037,15 +1013,14 @@ impl StdVideoH264SpsFlags {
         mb_adaptive_frame_field_flag: u32,
         frame_mbs_only_flag: u32,
         delta_pic_order_always_zero_flag: u32,
-        residual_colour_transform_flag: u32,
+        separate_colour_plane_flag: u32,
         gaps_in_frame_num_value_allowed_flag: u32,
-        first_picture_after_seek_flag: u32,
         qpprime_y_zero_transform_bypass_flag: u32,
         frame_cropping_flag: u32,
-        scaling_matrix_present_flag: u32,
+        seq_scaling_matrix_present_flag: u32,
         vui_parameters_present_flag: u32,
-    ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
+    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
         __bindgen_bitfield_unit.set(0usize, 1u8, {
             let constraint_set0_flag: u32 = unsafe { ::std::mem::transmute(constraint_set0_flag) };
             constraint_set0_flag as u64
@@ -1090,9 +1065,9 @@ impl StdVideoH264SpsFlags {
             delta_pic_order_always_zero_flag as u64
         });
         __bindgen_bitfield_unit.set(10usize, 1u8, {
-            let residual_colour_transform_flag: u32 =
-                unsafe { ::std::mem::transmute(residual_colour_transform_flag) };
-            residual_colour_transform_flag as u64
+            let separate_colour_plane_flag: u32 =
+                unsafe { ::std::mem::transmute(separate_colour_plane_flag) };
+            separate_colour_plane_flag as u64
         });
         __bindgen_bitfield_unit.set(11usize, 1u8, {
             let gaps_in_frame_num_value_allowed_flag: u32 =
@@ -1100,25 +1075,20 @@ impl StdVideoH264SpsFlags {
             gaps_in_frame_num_value_allowed_flag as u64
         });
         __bindgen_bitfield_unit.set(12usize, 1u8, {
-            let first_picture_after_seek_flag: u32 =
-                unsafe { ::std::mem::transmute(first_picture_after_seek_flag) };
-            first_picture_after_seek_flag as u64
-        });
-        __bindgen_bitfield_unit.set(13usize, 1u8, {
             let qpprime_y_zero_transform_bypass_flag: u32 =
                 unsafe { ::std::mem::transmute(qpprime_y_zero_transform_bypass_flag) };
             qpprime_y_zero_transform_bypass_flag as u64
         });
-        __bindgen_bitfield_unit.set(14usize, 1u8, {
+        __bindgen_bitfield_unit.set(13usize, 1u8, {
             let frame_cropping_flag: u32 = unsafe { ::std::mem::transmute(frame_cropping_flag) };
             frame_cropping_flag as u64
         });
-        __bindgen_bitfield_unit.set(15usize, 1u8, {
-            let scaling_matrix_present_flag: u32 =
-                unsafe { ::std::mem::transmute(scaling_matrix_present_flag) };
-            scaling_matrix_present_flag as u64
+        __bindgen_bitfield_unit.set(14usize, 1u8, {
+            let seq_scaling_matrix_present_flag: u32 =
+                unsafe { ::std::mem::transmute(seq_scaling_matrix_present_flag) };
+            seq_scaling_matrix_present_flag as u64
         });
-        __bindgen_bitfield_unit.set(16usize, 1u8, {
+        __bindgen_bitfield_unit.set(15usize, 1u8, {
             let vui_parameters_present_flag: u32 =
                 unsafe { ::std::mem::transmute(vui_parameters_present_flag) };
             vui_parameters_present_flag as u64
@@ -1127,30 +1097,30 @@ impl StdVideoH264SpsFlags {
     }
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 pub struct StdVideoH264ScalingLists {
-    pub scaling_list_present_mask: u8,
-    pub use_default_scaling_matrix_mask: u8,
+    pub scaling_list_present_mask: u16,
+    pub use_default_scaling_matrix_mask: u16,
     pub ScalingList4x4: [[u8; 16usize]; 6usize],
-    pub ScalingList8x8: [[u8; 64usize]; 2usize],
+    pub ScalingList8x8: [[u8; 64usize]; 6usize],
 }
 #[test]
 fn bindgen_test_layout_StdVideoH264ScalingLists() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH264ScalingLists> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH264ScalingLists>(),
-        226usize,
+        484usize,
         concat!("Size of: ", stringify!(StdVideoH264ScalingLists))
     );
     assert_eq!(
         ::std::mem::align_of::<StdVideoH264ScalingLists>(),
-        1usize,
+        2usize,
         concat!("Alignment of ", stringify!(StdVideoH264ScalingLists))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264ScalingLists>())).scaling_list_present_mask
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).scaling_list_present_mask) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -1161,10 +1131,9 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264ScalingLists>())).use_default_scaling_matrix_mask
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).use_default_scaling_matrix_mask) as usize - ptr as usize
         },
-        1usize,
+        2usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264ScalingLists),
@@ -1173,10 +1142,8 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264ScalingLists>())).ScalingList4x4 as *const _ as usize
-        },
-        2usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize },
+        4usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264ScalingLists),
@@ -1185,10 +1152,8 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264ScalingLists>())).ScalingList8x8 as *const _ as usize
-        },
-        98usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize },
+        100usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264ScalingLists),
@@ -1198,37 +1163,42 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() {
     );
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 pub struct StdVideoH264SequenceParameterSet {
+    pub flags: StdVideoH264SpsFlags,
     pub profile_idc: StdVideoH264ProfileIdc,
-    pub level_idc: StdVideoH264Level,
-    pub seq_parameter_set_id: u8,
+    pub level_idc: StdVideoH264LevelIdc,
     pub chroma_format_idc: StdVideoH264ChromaFormatIdc,
+    pub seq_parameter_set_id: u8,
     pub bit_depth_luma_minus8: u8,
     pub bit_depth_chroma_minus8: u8,
     pub log2_max_frame_num_minus4: u8,
     pub pic_order_cnt_type: StdVideoH264PocType,
-    pub log2_max_pic_order_cnt_lsb_minus4: u8,
     pub offset_for_non_ref_pic: i32,
     pub offset_for_top_to_bottom_field: i32,
+    pub log2_max_pic_order_cnt_lsb_minus4: u8,
     pub num_ref_frames_in_pic_order_cnt_cycle: u8,
     pub max_num_ref_frames: u8,
+    pub reserved1: u8,
     pub pic_width_in_mbs_minus1: u32,
     pub pic_height_in_map_units_minus1: u32,
     pub frame_crop_left_offset: u32,
     pub frame_crop_right_offset: u32,
     pub frame_crop_top_offset: u32,
     pub frame_crop_bottom_offset: u32,
-    pub flags: StdVideoH264SpsFlags,
-    pub offset_for_ref_frame: [i32; 255usize],
-    pub pScalingLists: *mut StdVideoH264ScalingLists,
-    pub pSequenceParameterSetVui: *mut StdVideoH264SequenceParameterSetVui,
+    pub reserved2: u32,
+    pub pOffsetForRefFrame: *const i32,
+    pub pScalingLists: *const StdVideoH264ScalingLists,
+    pub pSequenceParameterSetVui: *const StdVideoH264SequenceParameterSetVui,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH264SequenceParameterSet> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH264SequenceParameterSet>(),
-        1104usize,
+        88usize,
         concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSet))
     );
     assert_eq!(
@@ -1240,49 +1210,37 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).profile_idc as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(profile_idc)
+            stringify!(flags)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).level_idc as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).profile_idc) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(level_idc)
+            stringify!(profile_idc)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).seq_parameter_set_id
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).level_idc) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(seq_parameter_set_id)
+            stringify!(level_idc)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).chroma_format_idc
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -1292,49 +1250,47 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).bit_depth_luma_minus8
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(bit_depth_luma_minus8)
+            stringify!(seq_parameter_set_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).bit_depth_chroma_minus8
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize },
         17usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(bit_depth_chroma_minus8)
+            stringify!(bit_depth_luma_minus8)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).log2_max_frame_num_minus4
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize },
         18usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
+            stringify!(bit_depth_chroma_minus8)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).log2_max_frame_num_minus4) as usize - ptr as usize },
+        19usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH264SequenceParameterSet),
+            "::",
             stringify!(log2_max_frame_num_minus4)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).pic_order_cnt_type
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pic_order_cnt_type) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -1344,50 +1300,45 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>()))
-                .log2_max_pic_order_cnt_lsb_minus4 as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).offset_for_non_ref_pic) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(log2_max_pic_order_cnt_lsb_minus4)
+            stringify!(offset_for_non_ref_pic)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).offset_for_non_ref_pic
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).offset_for_top_to_bottom_field) as usize - ptr as usize
         },
         28usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(offset_for_non_ref_pic)
+            stringify!(offset_for_top_to_bottom_field)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>()))
-                .offset_for_top_to_bottom_field as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize
         },
         32usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(offset_for_top_to_bottom_field)
+            stringify!(log2_max_pic_order_cnt_lsb_minus4)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>()))
-                .num_ref_frames_in_pic_order_cnt_cycle as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_frames_in_pic_order_cnt_cycle) as usize
+                - ptr as usize
         },
-        36usize,
+        33usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1396,11 +1347,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).max_num_ref_frames
-                as *const _ as usize
-        },
-        37usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).max_num_ref_frames) as usize - ptr as usize },
+        34usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1409,11 +1357,18 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).pic_width_in_mbs_minus1
-                as *const _ as usize
-        },
-        40usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        35usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH264SequenceParameterSet),
+            "::",
+            stringify!(reserved1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_mbs_minus1) as usize - ptr as usize },
+        36usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1423,10 +1378,9 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>()))
-                .pic_height_in_map_units_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).pic_height_in_map_units_minus1) as usize - ptr as usize
         },
-        44usize,
+        40usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1435,11 +1389,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).frame_crop_left_offset
-                as *const _ as usize
-        },
-        48usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_left_offset) as usize - ptr as usize },
+        44usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1448,11 +1399,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).frame_crop_right_offset
-                as *const _ as usize
-        },
-        52usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_right_offset) as usize - ptr as usize },
+        48usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1461,11 +1409,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).frame_crop_top_offset
-                as *const _ as usize
-        },
-        56usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_top_offset) as usize - ptr as usize },
+        52usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1474,11 +1419,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).frame_crop_bottom_offset
-                as *const _ as usize
-        },
-        60usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_bottom_offset) as usize - ptr as usize },
+        56usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1487,36 +1429,28 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).flags as *const _ as usize
-        },
-        64usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
+        60usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(flags)
+            stringify!(reserved2)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).offset_for_ref_frame
-                as *const _ as usize
-        },
-        68usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pOffsetForRefFrame) as usize - ptr as usize },
+        64usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
             "::",
-            stringify!(offset_for_ref_frame)
+            stringify!(pOffsetForRefFrame)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).pScalingLists as *const _
-                as usize
-        },
-        1088usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
+        72usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1525,11 +1459,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264SequenceParameterSet>())).pSequenceParameterSetVui
-                as *const _ as usize
-        },
-        1096usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize },
+        80usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264SequenceParameterSet),
@@ -1543,8 +1474,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH264PpsFlags {
     pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
-    pub __bindgen_padding_0: u16,
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
 }
 #[test]
 fn bindgen_test_layout_StdVideoH264PpsFlags() {
@@ -1605,73 +1536,61 @@ impl StdVideoH264PpsFlags {
         }
     }
     #[inline]
-    pub fn weighted_bipred_idc_flag(&self) -> u32 {
+    pub fn weighted_pred_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_weighted_bipred_idc_flag(&mut self, val: u32) {
+    pub fn set_weighted_pred_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(4usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn weighted_pred_flag(&self) -> u32 {
+    pub fn bottom_field_pic_order_in_frame_present_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_weighted_pred_flag(&mut self, val: u32) {
+    pub fn set_bottom_field_pic_order_in_frame_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(5usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn pic_order_present_flag(&self) -> u32 {
+    pub fn entropy_coding_mode_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_pic_order_present_flag(&mut self, val: u32) {
+    pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(6usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn entropy_coding_mode_flag(&self) -> u32 {
+    pub fn pic_scaling_matrix_present_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
+    pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(7usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn scaling_matrix_present_flag(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_scaling_matrix_present_flag(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(8usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
     pub fn new_bitfield_1(
         transform_8x8_mode_flag: u32,
         redundant_pic_cnt_present_flag: u32,
         constrained_intra_pred_flag: u32,
         deblocking_filter_control_present_flag: u32,
-        weighted_bipred_idc_flag: u32,
         weighted_pred_flag: u32,
-        pic_order_present_flag: u32,
+        bottom_field_pic_order_in_frame_present_flag: u32,
         entropy_coding_mode_flag: u32,
-        scaling_matrix_present_flag: u32,
-    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
+        pic_scaling_matrix_present_flag: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
         __bindgen_bitfield_unit.set(0usize, 1u8, {
             let transform_8x8_mode_flag: u32 =
                 unsafe { ::std::mem::transmute(transform_8x8_mode_flag) };
@@ -1693,28 +1612,23 @@ impl StdVideoH264PpsFlags {
             deblocking_filter_control_present_flag as u64
         });
         __bindgen_bitfield_unit.set(4usize, 1u8, {
-            let weighted_bipred_idc_flag: u32 =
-                unsafe { ::std::mem::transmute(weighted_bipred_idc_flag) };
-            weighted_bipred_idc_flag as u64
-        });
-        __bindgen_bitfield_unit.set(5usize, 1u8, {
             let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) };
             weighted_pred_flag as u64
         });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
-            let pic_order_present_flag: u32 =
-                unsafe { ::std::mem::transmute(pic_order_present_flag) };
-            pic_order_present_flag as u64
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
+            let bottom_field_pic_order_in_frame_present_flag: u32 =
+                unsafe { ::std::mem::transmute(bottom_field_pic_order_in_frame_present_flag) };
+            bottom_field_pic_order_in_frame_present_flag as u64
         });
-        __bindgen_bitfield_unit.set(7usize, 1u8, {
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
             let entropy_coding_mode_flag: u32 =
                 unsafe { ::std::mem::transmute(entropy_coding_mode_flag) };
             entropy_coding_mode_flag as u64
         });
-        __bindgen_bitfield_unit.set(8usize, 1u8, {
-            let scaling_matrix_present_flag: u32 =
-                unsafe { ::std::mem::transmute(scaling_matrix_present_flag) };
-            scaling_matrix_present_flag as u64
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
+            let pic_scaling_matrix_present_flag: u32 =
+                unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) };
+            pic_scaling_matrix_present_flag as u64
         });
         __bindgen_bitfield_unit
     }
@@ -1722,20 +1636,23 @@ impl StdVideoH264PpsFlags {
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH264PictureParameterSet {
+    pub flags: StdVideoH264PpsFlags,
     pub seq_parameter_set_id: u8,
     pub pic_parameter_set_id: u8,
     pub num_ref_idx_l0_default_active_minus1: u8,
     pub num_ref_idx_l1_default_active_minus1: u8,
-    pub weighted_bipred_idc: StdVideoH264WeightedBiPredIdc,
+    pub weighted_bipred_idc: StdVideoH264WeightedBipredIdc,
     pub pic_init_qp_minus26: i8,
     pub pic_init_qs_minus26: i8,
     pub chroma_qp_index_offset: i8,
     pub second_chroma_qp_index_offset: i8,
-    pub flags: StdVideoH264PpsFlags,
-    pub pScalingLists: *mut StdVideoH264ScalingLists,
+    pub pScalingLists: *const StdVideoH264ScalingLists,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH264PictureParameterSet> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH264PictureParameterSet>(),
         24usize,
@@ -1747,24 +1664,28 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
         concat!("Alignment of ", stringify!(StdVideoH264PictureParameterSet))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>())).seq_parameter_set_id
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264PictureParameterSet),
             "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH264PictureParameterSet),
+            "::",
             stringify!(seq_parameter_set_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>())).pic_parameter_set_id
-                as *const _ as usize
-        },
-        1usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
+        5usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264PictureParameterSet),
@@ -1774,10 +1695,10 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>()))
-                .num_ref_idx_l0_default_active_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize
+                - ptr as usize
         },
-        2usize,
+        6usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264PictureParameterSet),
@@ -1787,10 +1708,10 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>()))
-                .num_ref_idx_l1_default_active_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize
+                - ptr as usize
         },
-        3usize,
+        7usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264PictureParameterSet),
@@ -1799,11 +1720,8 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>())).weighted_bipred_idc
-                as *const _ as usize
-        },
-        4usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).weighted_bipred_idc) as usize - ptr as usize },
+        8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264PictureParameterSet),
@@ -1812,11 +1730,8 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>())).pic_init_qp_minus26
-                as *const _ as usize
-        },
-        8usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pic_init_qp_minus26) as usize - ptr as usize },
+        12usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264PictureParameterSet),
@@ -1825,11 +1740,8 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>())).pic_init_qs_minus26
-                as *const _ as usize
-        },
-        9usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pic_init_qs_minus26) as usize - ptr as usize },
+        13usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264PictureParameterSet),
@@ -1838,11 +1750,8 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>())).chroma_qp_index_offset
-                as *const _ as usize
-        },
-        10usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_qp_index_offset) as usize - ptr as usize },
+        14usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264PictureParameterSet),
@@ -1852,10 +1761,9 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>()))
-                .second_chroma_qp_index_offset as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).second_chroma_qp_index_offset) as usize - ptr as usize
         },
-        11usize,
+        15usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH264PictureParameterSet),
@@ -1864,22 +1772,7 @@ fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>())).flags as *const _ as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoH264PictureParameterSet),
-            "::",
-            stringify!(flags)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH264PictureParameterSet>())).pScalingLists as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -1937,42 +1830,54 @@ impl StdVideoDecodeH264PictureInfoFlags {
         }
     }
     #[inline]
-    pub fn bottom_field_flag(&self) -> u32 {
+    pub fn IdrPicFlag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_bottom_field_flag(&mut self, val: u32) {
+    pub fn set_IdrPicFlag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(2usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn is_reference(&self) -> u32 {
+    pub fn bottom_field_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_is_reference(&mut self, val: u32) {
+    pub fn set_bottom_field_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(3usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn complementary_field_pair(&self) -> u32 {
+    pub fn is_reference(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_complementary_field_pair(&mut self, val: u32) {
+    pub fn set_is_reference(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(4usize, 1u8, val as u64)
         }
     }
     #[inline]
+    pub fn complementary_field_pair(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_complementary_field_pair(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(5usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
     pub fn new_bitfield_1(
         field_pic_flag: u32,
         is_intra: u32,
+        IdrPicFlag: u32,
         bottom_field_flag: u32,
         is_reference: u32,
         complementary_field_pair: u32,
@@ -1987,14 +1892,18 @@ impl StdVideoDecodeH264PictureInfoFlags {
             is_intra as u64
         });
         __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let IdrPicFlag: u32 = unsafe { ::std::mem::transmute(IdrPicFlag) };
+            IdrPicFlag as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
             let bottom_field_flag: u32 = unsafe { ::std::mem::transmute(bottom_field_flag) };
             bottom_field_flag as u64
         });
-        __bindgen_bitfield_unit.set(3usize, 1u8, {
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
             let is_reference: u32 = unsafe { ::std::mem::transmute(is_reference) };
             is_reference as u64
         });
-        __bindgen_bitfield_unit.set(4usize, 1u8, {
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
             let complementary_field_pair: u32 =
                 unsafe { ::std::mem::transmute(complementary_field_pair) };
             complementary_field_pair as u64
@@ -2005,16 +1914,20 @@ impl StdVideoDecodeH264PictureInfoFlags {
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoDecodeH264PictureInfo {
+    pub flags: StdVideoDecodeH264PictureInfoFlags,
     pub seq_parameter_set_id: u8,
     pub pic_parameter_set_id: u8,
-    pub reserved: u16,
+    pub reserved1: u8,
+    pub reserved2: u8,
     pub frame_num: u16,
     pub idr_pic_id: u16,
     pub PicOrderCnt: [i32; 2usize],
-    pub flags: StdVideoDecodeH264PictureInfoFlags,
 }
 #[test]
 fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoDecodeH264PictureInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoDecodeH264PictureInfo>(),
         20usize,
@@ -2026,24 +1939,28 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() {
         concat!("Alignment of ", stringify!(StdVideoDecodeH264PictureInfo))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264PictureInfo>())).seq_parameter_set_id
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH264PictureInfo),
             "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoDecodeH264PictureInfo),
+            "::",
             stringify!(seq_parameter_set_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264PictureInfo>())).pic_parameter_set_id
-                as *const _ as usize
-        },
-        1usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
+        5usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH264PictureInfo),
@@ -2052,65 +1969,53 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264PictureInfo>())).reserved as *const _ as usize
-        },
-        2usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        6usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH264PictureInfo),
             "::",
-            stringify!(reserved)
+            stringify!(reserved1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264PictureInfo>())).frame_num as *const _ as usize
-        },
-        4usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
+        7usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH264PictureInfo),
             "::",
-            stringify!(frame_num)
+            stringify!(reserved2)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264PictureInfo>())).idr_pic_id as *const _
-                as usize
-        },
-        6usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize },
+        8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH264PictureInfo),
             "::",
-            stringify!(idr_pic_id)
+            stringify!(frame_num)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264PictureInfo>())).PicOrderCnt as *const _
-                as usize
-        },
-        8usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize },
+        10usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH264PictureInfo),
             "::",
-            stringify!(PicOrderCnt)
+            stringify!(idr_pic_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264PictureInfo>())).flags as *const _ as usize
-        },
-        16usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
+        12usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH264PictureInfo),
             "::",
-            stringify!(flags)
+            stringify!(PicOrderCnt)
         )
     );
 }
@@ -2165,11 +2070,11 @@ impl StdVideoDecodeH264ReferenceInfoFlags {
         }
     }
     #[inline]
-    pub fn is_long_term(&self) -> u32 {
+    pub fn used_for_long_term_reference(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_is_long_term(&mut self, val: u32) {
+    pub fn set_used_for_long_term_reference(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(2usize, 1u8, val as u64)
@@ -2190,7 +2095,7 @@ impl StdVideoDecodeH264ReferenceInfoFlags {
     pub fn new_bitfield_1(
         top_field_flag: u32,
         bottom_field_flag: u32,
-        is_long_term: u32,
+        used_for_long_term_reference: u32,
         is_non_existing: u32,
     ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
         let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
@@ -2203,8 +2108,9 @@ impl StdVideoDecodeH264ReferenceInfoFlags {
             bottom_field_flag as u64
         });
         __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let is_long_term: u32 = unsafe { ::std::mem::transmute(is_long_term) };
-            is_long_term as u64
+            let used_for_long_term_reference: u32 =
+                unsafe { ::std::mem::transmute(used_for_long_term_reference) };
+            used_for_long_term_reference as u64
         });
         __bindgen_bitfield_unit.set(3usize, 1u8, {
             let is_non_existing: u32 = unsafe { ::std::mem::transmute(is_non_existing) };
@@ -2216,13 +2122,16 @@ impl StdVideoDecodeH264ReferenceInfoFlags {
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoDecodeH264ReferenceInfo {
+    pub flags: StdVideoDecodeH264ReferenceInfoFlags,
     pub FrameNum: u16,
     pub reserved: u16,
     pub PicOrderCnt: [i32; 2usize],
-    pub flags: StdVideoDecodeH264ReferenceInfoFlags,
 }
 #[test]
 fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoDecodeH264ReferenceInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoDecodeH264ReferenceInfo>(),
         16usize,
@@ -2234,412 +2143,135 @@ fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() {
         concat!("Alignment of ", stringify!(StdVideoDecodeH264ReferenceInfo))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264ReferenceInfo>())).FrameNum as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH264ReferenceInfo),
             "::",
-            stringify!(FrameNum)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264ReferenceInfo>())).reserved as *const _
-                as usize
-        },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264ReferenceInfo),
-            "::",
-            stringify!(reserved)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264ReferenceInfo>())).PicOrderCnt as *const _
-                as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264ReferenceInfo),
-            "::",
-            stringify!(PicOrderCnt)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264ReferenceInfo>())).flags as *const _ as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264ReferenceInfo),
-            "::",
             stringify!(flags)
         )
     );
-}
-#[repr(C)]
-#[repr(align(4))]
-#[derive(Debug, Copy, Clone)]
-pub struct StdVideoDecodeH264MvcElementFlags {
-    pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub __bindgen_padding_0: [u8; 3usize],
-}
-#[test]
-fn bindgen_test_layout_StdVideoDecodeH264MvcElementFlags() {
-    assert_eq!(
-        ::std::mem::size_of::<StdVideoDecodeH264MvcElementFlags>(),
-        4usize,
-        concat!("Size of: ", stringify!(StdVideoDecodeH264MvcElementFlags))
-    );
     assert_eq!(
-        ::std::mem::align_of::<StdVideoDecodeH264MvcElementFlags>(),
+        unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize },
         4usize,
         concat!(
-            "Alignment of ",
-            stringify!(StdVideoDecodeH264MvcElementFlags)
-        )
-    );
-}
-impl StdVideoDecodeH264MvcElementFlags {
-    #[inline]
-    pub fn non_idr(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_non_idr(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(0usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn anchor_pic(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_anchor_pic(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn inter_view(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_inter_view(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn new_bitfield_1(
-        non_idr: u32,
-        anchor_pic: u32,
-        inter_view: u32,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
-        __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let non_idr: u32 = unsafe { ::std::mem::transmute(non_idr) };
-            non_idr as u64
-        });
-        __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let anchor_pic: u32 = unsafe { ::std::mem::transmute(anchor_pic) };
-            anchor_pic as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let inter_view: u32 = unsafe { ::std::mem::transmute(inter_view) };
-            inter_view as u64
-        });
-        __bindgen_bitfield_unit
-    }
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StdVideoDecodeH264MvcElement {
-    pub flags: StdVideoDecodeH264MvcElementFlags,
-    pub viewOrderIndex: u16,
-    pub viewId: u16,
-    pub temporalId: u16,
-    pub priorityId: u16,
-    pub numOfAnchorRefsInL0: u16,
-    pub viewIdOfAnchorRefsInL0: [u16; 15usize],
-    pub numOfAnchorRefsInL1: u16,
-    pub viewIdOfAnchorRefsInL1: [u16; 15usize],
-    pub numOfNonAnchorRefsInL0: u16,
-    pub viewIdOfNonAnchorRefsInL0: [u16; 15usize],
-    pub numOfNonAnchorRefsInL1: u16,
-    pub viewIdOfNonAnchorRefsInL1: [u16; 15usize],
-}
-#[test]
-fn bindgen_test_layout_StdVideoDecodeH264MvcElement() {
-    assert_eq!(
-        ::std::mem::size_of::<StdVideoDecodeH264MvcElement>(),
-        140usize,
-        concat!("Size of: ", stringify!(StdVideoDecodeH264MvcElement))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<StdVideoDecodeH264MvcElement>(),
-        4usize,
-        concat!("Alignment of ", stringify!(StdVideoDecodeH264MvcElement))
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).flags as *const _ as usize
-        },
-        0usize,
-        concat!(
             "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(flags)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).viewOrderIndex as *const _
-                as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
+            stringify!(StdVideoDecodeH264ReferenceInfo),
             "::",
-            stringify!(viewOrderIndex)
+            stringify!(FrameNum)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).viewId as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(viewId)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).temporalId as *const _ as usize
-        },
-        8usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(temporalId)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).priorityId as *const _ as usize
-        },
-        10usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(priorityId)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).numOfAnchorRefsInL0 as *const _
-                as usize
-        },
-        12usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(numOfAnchorRefsInL0)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).viewIdOfAnchorRefsInL0
-                as *const _ as usize
-        },
-        14usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(viewIdOfAnchorRefsInL0)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).numOfAnchorRefsInL1 as *const _
-                as usize
-        },
-        44usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(numOfAnchorRefsInL1)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).viewIdOfAnchorRefsInL1
-                as *const _ as usize
-        },
-        46usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(viewIdOfAnchorRefsInL1)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).numOfNonAnchorRefsInL0
-                as *const _ as usize
-        },
-        76usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(numOfNonAnchorRefsInL0)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).viewIdOfNonAnchorRefsInL0
-                as *const _ as usize
-        },
-        78usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(viewIdOfNonAnchorRefsInL0)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).numOfNonAnchorRefsInL1
-                as *const _ as usize
-        },
-        108usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(numOfNonAnchorRefsInL1)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264MvcElement>())).viewIdOfNonAnchorRefsInL1
-                as *const _ as usize
-        },
-        110usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264MvcElement),
-            "::",
-            stringify!(viewIdOfNonAnchorRefsInL1)
-        )
-    );
-}
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct StdVideoDecodeH264Mvc {
-    pub viewId0: u32,
-    pub mvcElementCount: u32,
-    pub pMvcElements: *mut StdVideoDecodeH264MvcElement,
-}
-#[test]
-fn bindgen_test_layout_StdVideoDecodeH264Mvc() {
-    assert_eq!(
-        ::std::mem::size_of::<StdVideoDecodeH264Mvc>(),
-        16usize,
-        concat!("Size of: ", stringify!(StdVideoDecodeH264Mvc))
-    );
-    assert_eq!(
-        ::std::mem::align_of::<StdVideoDecodeH264Mvc>(),
-        8usize,
-        concat!("Alignment of ", stringify!(StdVideoDecodeH264Mvc))
-    );
-    assert_eq!(
-        unsafe { &(*(::std::ptr::null::<StdVideoDecodeH264Mvc>())).viewId0 as *const _ as usize },
-        0usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264Mvc),
-            "::",
-            stringify!(viewId0)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264Mvc>())).mvcElementCount as *const _ as usize
-        },
-        4usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoDecodeH264Mvc),
+            stringify!(StdVideoDecodeH264ReferenceInfo),
             "::",
-            stringify!(mvcElementCount)
+            stringify!(reserved)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH264Mvc>())).pMvcElements as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoDecodeH264Mvc),
+            stringify!(StdVideoDecodeH264ReferenceInfo),
             "::",
-            stringify!(pMvcElements)
+            stringify!(PicOrderCnt)
         )
     );
 }
-pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_main: StdVideoH265ProfileIdc = 1;
-pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_main_10: StdVideoH265ProfileIdc = 2;
-pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_main_still_picture:
+pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME:
+    StdVideoH265ChromaFormatIdc = 0;
+pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_420:
+    StdVideoH265ChromaFormatIdc = 1;
+pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_422:
+    StdVideoH265ChromaFormatIdc = 2;
+pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_444:
+    StdVideoH265ChromaFormatIdc = 3;
+pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID:
+    StdVideoH265ChromaFormatIdc = 2147483647;
+pub type StdVideoH265ChromaFormatIdc = ::std::os::raw::c_uint;
+pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN: StdVideoH265ProfileIdc = 1;
+pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_10: StdVideoH265ProfileIdc = 2;
+pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE:
     StdVideoH265ProfileIdc = 3;
-pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_format_range_extensions:
+pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS:
     StdVideoH265ProfileIdc = 4;
-pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_scc_extensions: StdVideoH265ProfileIdc =
+pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: StdVideoH265ProfileIdc =
     9;
-pub const StdVideoH265ProfileIdc_std_video_h265_profile_idc_invalid: StdVideoH265ProfileIdc =
+pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_INVALID: StdVideoH265ProfileIdc =
     2147483647;
 pub type StdVideoH265ProfileIdc = ::std::os::raw::c_uint;
-pub const StdVideoH265Level_std_video_h265_level_1_0: StdVideoH265Level = 0;
-pub const StdVideoH265Level_std_video_h265_level_2_0: StdVideoH265Level = 1;
-pub const StdVideoH265Level_std_video_h265_level_2_1: StdVideoH265Level = 2;
-pub const StdVideoH265Level_std_video_h265_level_3_0: StdVideoH265Level = 3;
-pub const StdVideoH265Level_std_video_h265_level_3_1: StdVideoH265Level = 4;
-pub const StdVideoH265Level_std_video_h265_level_4_0: StdVideoH265Level = 5;
-pub const StdVideoH265Level_std_video_h265_level_4_1: StdVideoH265Level = 6;
-pub const StdVideoH265Level_std_video_h265_level_5_0: StdVideoH265Level = 7;
-pub const StdVideoH265Level_std_video_h265_level_5_1: StdVideoH265Level = 8;
-pub const StdVideoH265Level_std_video_h265_level_5_2: StdVideoH265Level = 9;
-pub const StdVideoH265Level_std_video_h265_level_6_0: StdVideoH265Level = 10;
-pub const StdVideoH265Level_std_video_h265_level_6_1: StdVideoH265Level = 11;
-pub const StdVideoH265Level_std_video_h265_level_6_2: StdVideoH265Level = 12;
-pub const StdVideoH265Level_std_video_h265_level_invalid: StdVideoH265Level = 2147483647;
-pub type StdVideoH265Level = ::std::os::raw::c_uint;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_1_0: StdVideoH265LevelIdc = 0;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_0: StdVideoH265LevelIdc = 1;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_1: StdVideoH265LevelIdc = 2;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_0: StdVideoH265LevelIdc = 3;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_1: StdVideoH265LevelIdc = 4;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_0: StdVideoH265LevelIdc = 5;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_1: StdVideoH265LevelIdc = 6;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_0: StdVideoH265LevelIdc = 7;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_1: StdVideoH265LevelIdc = 8;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_2: StdVideoH265LevelIdc = 9;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_0: StdVideoH265LevelIdc = 10;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_1: StdVideoH265LevelIdc = 11;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_2: StdVideoH265LevelIdc = 12;
+pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_INVALID: StdVideoH265LevelIdc = 2147483647;
+pub type StdVideoH265LevelIdc = ::std::os::raw::c_uint;
+pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_B: StdVideoH265SliceType = 0;
+pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_P: StdVideoH265SliceType = 1;
+pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_I: StdVideoH265SliceType = 2;
+pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_INVALID: StdVideoH265SliceType =
+    2147483647;
+pub type StdVideoH265SliceType = ::std::os::raw::c_uint;
+pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_P: StdVideoH265PictureType = 0;
+pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_B: StdVideoH265PictureType = 1;
+pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_I: StdVideoH265PictureType = 2;
+pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_IDR: StdVideoH265PictureType = 3;
+pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_INVALID: StdVideoH265PictureType =
+    2147483647;
+pub type StdVideoH265PictureType = ::std::os::raw::c_uint;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED:
+    StdVideoH265AspectRatioIdc = 0;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE:
+    StdVideoH265AspectRatioIdc = 1;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11:
+    StdVideoH265AspectRatioIdc = 2;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11:
+    StdVideoH265AspectRatioIdc = 3;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11:
+    StdVideoH265AspectRatioIdc = 4;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33:
+    StdVideoH265AspectRatioIdc = 5;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11:
+    StdVideoH265AspectRatioIdc = 6;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11:
+    StdVideoH265AspectRatioIdc = 7;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11:
+    StdVideoH265AspectRatioIdc = 8;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33:
+    StdVideoH265AspectRatioIdc = 9;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11:
+    StdVideoH265AspectRatioIdc = 10;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11:
+    StdVideoH265AspectRatioIdc = 11;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33:
+    StdVideoH265AspectRatioIdc = 12;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99:
+    StdVideoH265AspectRatioIdc = 13;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3:
+    StdVideoH265AspectRatioIdc = 14;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2:
+    StdVideoH265AspectRatioIdc = 15;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1:
+    StdVideoH265AspectRatioIdc = 16;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR:
+    StdVideoH265AspectRatioIdc = 255;
+pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID:
+    StdVideoH265AspectRatioIdc = 2147483647;
+pub type StdVideoH265AspectRatioIdc = ::std::os::raw::c_uint;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH265DecPicBufMgr {
@@ -2649,6 +2281,9 @@ pub struct StdVideoH265DecPicBufMgr {
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265DecPicBufMgr() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265DecPicBufMgr> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH265DecPicBufMgr>(),
         44usize,
@@ -2660,10 +2295,7 @@ fn bindgen_test_layout_StdVideoH265DecPicBufMgr() {
         concat!("Alignment of ", stringify!(StdVideoH265DecPicBufMgr))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265DecPicBufMgr>())).max_latency_increase_plus1
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).max_latency_increase_plus1) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -2674,8 +2306,7 @@ fn bindgen_test_layout_StdVideoH265DecPicBufMgr() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265DecPicBufMgr>())).max_dec_pic_buffering_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).max_dec_pic_buffering_minus1) as usize - ptr as usize
         },
         28usize,
         concat!(
@@ -2686,10 +2317,7 @@ fn bindgen_test_layout_StdVideoH265DecPicBufMgr() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265DecPicBufMgr>())).max_num_reorder_pics as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_pics) as usize - ptr as usize },
         35usize,
         concat!(
             "Offset of field: ",
@@ -2710,6 +2338,9 @@ pub struct StdVideoH265SubLayerHrdParameters {
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265SubLayerHrdParameters> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH265SubLayerHrdParameters>(),
         516usize,
@@ -2724,10 +2355,7 @@ fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SubLayerHrdParameters>())).bit_rate_value_minus1
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -2737,10 +2365,7 @@ fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SubLayerHrdParameters>())).cpb_size_value_minus1
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_value_minus1) as usize - ptr as usize },
         128usize,
         concat!(
             "Offset of field: ",
@@ -2750,10 +2375,7 @@ fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SubLayerHrdParameters>())).cpb_size_du_value_minus1
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_du_value_minus1) as usize - ptr as usize },
         256usize,
         concat!(
             "Offset of field: ",
@@ -2763,10 +2385,7 @@ fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SubLayerHrdParameters>())).bit_rate_du_value_minus1
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_du_value_minus1) as usize - ptr as usize },
         384usize,
         concat!(
             "Offset of field: ",
@@ -2776,10 +2395,7 @@ fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SubLayerHrdParameters>())).cbr_flag as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).cbr_flag) as usize - ptr as usize },
         512usize,
         concat!(
             "Offset of field: ",
@@ -2794,10 +2410,7 @@ fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() {
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH265HrdFlags {
     pub _bitfield_align_1: [u8; 0],
-    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
-    pub fixed_pic_rate_general_flag: u8,
-    pub fixed_pic_rate_within_cvs_flag: u8,
-    pub low_delay_hrd_flag: u8,
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265HrdFlags() {
@@ -2811,44 +2424,6 @@ fn bindgen_test_layout_StdVideoH265HrdFlags() {
         4usize,
         concat!("Alignment of ", stringify!(StdVideoH265HrdFlags))
     );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdFlags>())).fixed_pic_rate_general_flag as *const _
-                as usize
-        },
-        1usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoH265HrdFlags),
-            "::",
-            stringify!(fixed_pic_rate_general_flag)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdFlags>())).fixed_pic_rate_within_cvs_flag
-                as *const _ as usize
-        },
-        2usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoH265HrdFlags),
-            "::",
-            stringify!(fixed_pic_rate_within_cvs_flag)
-        )
-    );
-    assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdFlags>())).low_delay_hrd_flag as *const _ as usize
-        },
-        3usize,
-        concat!(
-            "Offset of field: ",
-            stringify!(StdVideoH265HrdFlags),
-            "::",
-            stringify!(low_delay_hrd_flag)
-        )
-    );
 }
 impl StdVideoH265HrdFlags {
     #[inline]
@@ -2896,13 +2471,49 @@ impl StdVideoH265HrdFlags {
         }
     }
     #[inline]
+    pub fn fixed_pic_rate_general_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) }
+    }
+    #[inline]
+    pub fn set_fixed_pic_rate_general_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn fixed_pic_rate_within_cvs_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) }
+    }
+    #[inline]
+    pub fn set_fixed_pic_rate_within_cvs_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(12usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn low_delay_hrd_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 8u8) as u32) }
+    }
+    #[inline]
+    pub fn set_low_delay_hrd_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(20usize, 8u8, val as u64)
+        }
+    }
+    #[inline]
     pub fn new_bitfield_1(
         nal_hrd_parameters_present_flag: u32,
         vcl_hrd_parameters_present_flag: u32,
         sub_pic_hrd_params_present_flag: u32,
         sub_pic_cpb_params_in_pic_timing_sei_flag: u32,
-    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
-        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
+        fixed_pic_rate_general_flag: u32,
+        fixed_pic_rate_within_cvs_flag: u32,
+        low_delay_hrd_flag: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
         __bindgen_bitfield_unit.set(0usize, 1u8, {
             let nal_hrd_parameters_present_flag: u32 =
                 unsafe { ::std::mem::transmute(nal_hrd_parameters_present_flag) };
@@ -2923,12 +2534,27 @@ impl StdVideoH265HrdFlags {
                 unsafe { ::std::mem::transmute(sub_pic_cpb_params_in_pic_timing_sei_flag) };
             sub_pic_cpb_params_in_pic_timing_sei_flag as u64
         });
+        __bindgen_bitfield_unit.set(4usize, 8u8, {
+            let fixed_pic_rate_general_flag: u32 =
+                unsafe { ::std::mem::transmute(fixed_pic_rate_general_flag) };
+            fixed_pic_rate_general_flag as u64
+        });
+        __bindgen_bitfield_unit.set(12usize, 8u8, {
+            let fixed_pic_rate_within_cvs_flag: u32 =
+                unsafe { ::std::mem::transmute(fixed_pic_rate_within_cvs_flag) };
+            fixed_pic_rate_within_cvs_flag as u64
+        });
+        __bindgen_bitfield_unit.set(20usize, 8u8, {
+            let low_delay_hrd_flag: u32 = unsafe { ::std::mem::transmute(low_delay_hrd_flag) };
+            low_delay_hrd_flag as u64
+        });
         __bindgen_bitfield_unit
     }
 }
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH265HrdParameters {
+    pub flags: StdVideoH265HrdFlags,
     pub tick_divisor_minus2: u8,
     pub du_cpb_removal_delay_increment_length_minus1: u8,
     pub dpb_output_delay_du_length_minus1: u8,
@@ -2940,15 +2566,18 @@ pub struct StdVideoH265HrdParameters {
     pub dpb_output_delay_length_minus1: u8,
     pub cpb_cnt_minus1: [u8; 7usize],
     pub elemental_duration_in_tc_minus1: [u16; 7usize],
-    pub SubLayerHrdParametersNal: [*mut StdVideoH265SubLayerHrdParameters; 7usize],
-    pub SubLayerHrdParametersVcl: [*mut StdVideoH265SubLayerHrdParameters; 7usize],
-    pub flags: StdVideoH265HrdFlags,
+    pub reserved: [u16; 3usize],
+    pub pSubLayerHrdParametersNal: *const StdVideoH265SubLayerHrdParameters,
+    pub pSubLayerHrdParametersVcl: *const StdVideoH265SubLayerHrdParameters,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265HrdParameters() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265HrdParameters> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH265HrdParameters>(),
-        152usize,
+        56usize,
         concat!("Size of: ", stringify!(StdVideoH265HrdParameters))
     );
     assert_eq!(
@@ -2957,24 +2586,31 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
         concat!("Alignment of ", stringify!(StdVideoH265HrdParameters))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).tick_divisor_minus2 as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
             "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).tick_divisor_minus2) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265HrdParameters),
+            "::",
             stringify!(tick_divisor_minus2)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>()))
-                .du_cpb_removal_delay_increment_length_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).du_cpb_removal_delay_increment_length_minus1) as usize
+                - ptr as usize
         },
-        1usize,
+        5usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -2984,10 +2620,9 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).dpb_output_delay_du_length_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).dpb_output_delay_du_length_minus1) as usize - ptr as usize
         },
-        2usize,
+        6usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -2996,11 +2631,8 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).bit_rate_scale as *const _
-                as usize
-        },
-        3usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_scale) as usize - ptr as usize },
+        7usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -3009,11 +2641,8 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).cpb_size_scale as *const _
-                as usize
-        },
-        4usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_scale) as usize - ptr as usize },
+        8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -3022,11 +2651,8 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).cpb_size_du_scale as *const _
-                as usize
-        },
-        5usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_du_scale) as usize - ptr as usize },
+        9usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -3036,10 +2662,10 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>()))
-                .initial_cpb_removal_delay_length_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).initial_cpb_removal_delay_length_minus1) as usize
+                - ptr as usize
         },
-        6usize,
+        10usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -3049,10 +2675,9 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).au_cpb_removal_delay_length_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).au_cpb_removal_delay_length_minus1) as usize - ptr as usize
         },
-        7usize,
+        11usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -3062,10 +2687,9 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).dpb_output_delay_length_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).dpb_output_delay_length_minus1) as usize - ptr as usize
         },
-        8usize,
+        12usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -3074,11 +2698,8 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).cpb_cnt_minus1 as *const _
-                as usize
-        },
-        9usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).cpb_cnt_minus1) as usize - ptr as usize },
+        13usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -3088,10 +2709,9 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).elemental_duration_in_tc_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).elemental_duration_in_tc_minus1) as usize - ptr as usize
         },
-        16usize,
+        20usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
@@ -3100,39 +2720,33 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).SubLayerHrdParametersNal
-                as *const _ as usize
-        },
-        32usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
+        34usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
             "::",
-            stringify!(SubLayerHrdParametersNal)
+            stringify!(reserved)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).SubLayerHrdParametersVcl
-                as *const _ as usize
-        },
-        88usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersNal) as usize - ptr as usize },
+        40usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
             "::",
-            stringify!(SubLayerHrdParametersVcl)
+            stringify!(pSubLayerHrdParametersNal)
         )
     );
     assert_eq!(
-        unsafe { &(*(::std::ptr::null::<StdVideoH265HrdParameters>())).flags as *const _ as usize },
-        144usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersVcl) as usize - ptr as usize },
+        48usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265HrdParameters),
             "::",
-            stringify!(flags)
+            stringify!(pSubLayerHrdParametersVcl)
         )
     );
 }
@@ -3234,22 +2848,198 @@ impl StdVideoH265VpsFlags {
     }
 }
 #[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoH265ProfileTierLevelFlags {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoH265ProfileTierLevelFlags() {
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoH265ProfileTierLevelFlags>(),
+        4usize,
+        concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevelFlags))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoH265ProfileTierLevelFlags>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoH265ProfileTierLevelFlags)
+        )
+    );
+}
+impl StdVideoH265ProfileTierLevelFlags {
+    #[inline]
+    pub fn general_tier_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_general_tier_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn general_progressive_source_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_general_progressive_source_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn general_interlaced_source_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_general_interlaced_source_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn general_non_packed_constraint_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_general_non_packed_constraint_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn general_frame_only_constraint_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_general_frame_only_constraint_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        general_tier_flag: u32,
+        general_progressive_source_flag: u32,
+        general_interlaced_source_flag: u32,
+        general_non_packed_constraint_flag: u32,
+        general_frame_only_constraint_flag: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let general_tier_flag: u32 = unsafe { ::std::mem::transmute(general_tier_flag) };
+            general_tier_flag as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let general_progressive_source_flag: u32 =
+                unsafe { ::std::mem::transmute(general_progressive_source_flag) };
+            general_progressive_source_flag as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let general_interlaced_source_flag: u32 =
+                unsafe { ::std::mem::transmute(general_interlaced_source_flag) };
+            general_interlaced_source_flag as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let general_non_packed_constraint_flag: u32 =
+                unsafe { ::std::mem::transmute(general_non_packed_constraint_flag) };
+            general_non_packed_constraint_flag as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
+            let general_frame_only_constraint_flag: u32 =
+                unsafe { ::std::mem::transmute(general_frame_only_constraint_flag) };
+            general_frame_only_constraint_flag as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoH265ProfileTierLevel {
+    pub flags: StdVideoH265ProfileTierLevelFlags,
+    pub general_profile_idc: StdVideoH265ProfileIdc,
+    pub general_level_idc: StdVideoH265LevelIdc,
+}
+#[test]
+fn bindgen_test_layout_StdVideoH265ProfileTierLevel() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265ProfileTierLevel> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoH265ProfileTierLevel>(),
+        12usize,
+        concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevel))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoH265ProfileTierLevel>(),
+        4usize,
+        concat!("Alignment of ", stringify!(StdVideoH265ProfileTierLevel))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ProfileTierLevel),
+            "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).general_profile_idc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ProfileTierLevel),
+            "::",
+            stringify!(general_profile_idc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).general_level_idc) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ProfileTierLevel),
+            "::",
+            stringify!(general_level_idc)
+        )
+    );
+}
+#[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH265VideoParameterSet {
+    pub flags: StdVideoH265VpsFlags,
     pub vps_video_parameter_set_id: u8,
     pub vps_max_sub_layers_minus1: u8,
+    pub reserved1: u8,
+    pub reserved2: u8,
     pub vps_num_units_in_tick: u32,
     pub vps_time_scale: u32,
     pub vps_num_ticks_poc_diff_one_minus1: u32,
-    pub pDecPicBufMgr: *mut StdVideoH265DecPicBufMgr,
-    pub hrd_parameters: *mut StdVideoH265HrdParameters,
-    pub flags: StdVideoH265VpsFlags,
+    pub reserved3: u32,
+    pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr,
+    pub pHrdParameters: *const StdVideoH265HrdParameters,
+    pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265VideoParameterSet() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265VideoParameterSet> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH265VideoParameterSet>(),
-        40usize,
+        48usize,
         concat!("Size of: ", stringify!(StdVideoH265VideoParameterSet))
     );
     assert_eq!(
@@ -3258,24 +3048,28 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() {
         concat!("Alignment of ", stringify!(StdVideoH265VideoParameterSet))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265VideoParameterSet>())).vps_video_parameter_set_id
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265VideoParameterSet),
             "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).vps_video_parameter_set_id) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265VideoParameterSet),
+            "::",
             stringify!(vps_video_parameter_set_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265VideoParameterSet>())).vps_max_sub_layers_minus1
-                as *const _ as usize
-        },
-        1usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).vps_max_sub_layers_minus1) as usize - ptr as usize },
+        5usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265VideoParameterSet),
@@ -3284,85 +3078,100 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265VideoParameterSet>())).vps_num_units_in_tick
-                as *const _ as usize
-        },
-        4usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        6usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265VideoParameterSet),
             "::",
-            stringify!(vps_num_units_in_tick)
+            stringify!(reserved1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265VideoParameterSet>())).vps_time_scale as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
+        7usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265VideoParameterSet),
+            "::",
+            stringify!(reserved2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).vps_num_units_in_tick) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265VideoParameterSet),
             "::",
-            stringify!(vps_time_scale)
+            stringify!(vps_num_units_in_tick)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265VideoParameterSet>()))
-                .vps_num_ticks_poc_diff_one_minus1 as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).vps_time_scale) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265VideoParameterSet),
             "::",
-            stringify!(vps_num_ticks_poc_diff_one_minus1)
+            stringify!(vps_time_scale)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265VideoParameterSet>())).pDecPicBufMgr as *const _
-                as usize
+            ::std::ptr::addr_of!((*ptr).vps_num_ticks_poc_diff_one_minus1) as usize - ptr as usize
         },
         16usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265VideoParameterSet),
             "::",
-            stringify!(pDecPicBufMgr)
+            stringify!(vps_num_ticks_poc_diff_one_minus1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265VideoParameterSet>())).hrd_parameters as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
+        20usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265VideoParameterSet),
+            "::",
+            stringify!(reserved3)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265VideoParameterSet),
             "::",
-            stringify!(hrd_parameters)
+            stringify!(pDecPicBufMgr)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265VideoParameterSet>())).flags as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265VideoParameterSet),
             "::",
-            stringify!(flags)
+            stringify!(pHrdParameters)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265VideoParameterSet),
+            "::",
+            stringify!(pProfileTierLevel)
         )
     );
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 pub struct StdVideoH265ScalingLists {
     pub ScalingList4x4: [[u8; 16usize]; 6usize],
     pub ScalingList8x8: [[u8; 64usize]; 6usize],
@@ -3373,6 +3182,9 @@ pub struct StdVideoH265ScalingLists {
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265ScalingLists() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265ScalingLists> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH265ScalingLists>(),
         1000usize,
@@ -3384,9 +3196,7 @@ fn bindgen_test_layout_StdVideoH265ScalingLists() {
         concat!("Alignment of ", stringify!(StdVideoH265ScalingLists))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265ScalingLists>())).ScalingList4x4 as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -3396,9 +3206,7 @@ fn bindgen_test_layout_StdVideoH265ScalingLists() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265ScalingLists>())).ScalingList8x8 as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize },
         96usize,
         concat!(
             "Offset of field: ",
@@ -3408,10 +3216,7 @@ fn bindgen_test_layout_StdVideoH265ScalingLists() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265ScalingLists>())).ScalingList16x16 as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).ScalingList16x16) as usize - ptr as usize },
         480usize,
         concat!(
             "Offset of field: ",
@@ -3421,10 +3226,7 @@ fn bindgen_test_layout_StdVideoH265ScalingLists() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265ScalingLists>())).ScalingList32x32 as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).ScalingList32x32) as usize - ptr as usize },
         864usize,
         concat!(
             "Offset of field: ",
@@ -3434,10 +3236,7 @@ fn bindgen_test_layout_StdVideoH265ScalingLists() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265ScalingLists>())).ScalingListDCCoef16x16 as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).ScalingListDCCoef16x16) as usize - ptr as usize },
         992usize,
         concat!(
             "Offset of field: ",
@@ -3447,10 +3246,7 @@ fn bindgen_test_layout_StdVideoH265ScalingLists() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265ScalingLists>())).ScalingListDCCoef32x32 as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).ScalingListDCCoef32x32) as usize - ptr as usize },
         998usize,
         concat!(
             "Offset of field: ",
@@ -3797,7 +3593,8 @@ impl StdVideoH265SpsVuiFlags {
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH265SequenceParameterSetVui {
-    pub aspect_ratio_idc: u8,
+    pub flags: StdVideoH265SpsVuiFlags,
+    pub aspect_ratio_idc: StdVideoH265AspectRatioIdc,
     pub sar_width: u16,
     pub sar_height: u16,
     pub video_format: u8,
@@ -3806,6 +3603,8 @@ pub struct StdVideoH265SequenceParameterSetVui {
     pub matrix_coeffs: u8,
     pub chroma_sample_loc_type_top_field: u8,
     pub chroma_sample_loc_type_bottom_field: u8,
+    pub reserved1: u8,
+    pub reserved2: u8,
     pub def_disp_win_left_offset: u16,
     pub def_disp_win_right_offset: u16,
     pub def_disp_win_top_offset: u16,
@@ -3813,16 +3612,19 @@ pub struct StdVideoH265SequenceParameterSetVui {
     pub vui_num_units_in_tick: u32,
     pub vui_time_scale: u32,
     pub vui_num_ticks_poc_diff_one_minus1: u32,
-    pub hrd_parameters: *mut StdVideoH265HrdParameters,
     pub min_spatial_segmentation_idc: u16,
+    pub reserved3: u16,
     pub max_bytes_per_pic_denom: u8,
     pub max_bits_per_min_cu_denom: u8,
     pub log2_max_mv_length_horizontal: u8,
     pub log2_max_mv_length_vertical: u8,
-    pub flags: StdVideoH265SpsVuiFlags,
+    pub pHrdParameters: *const StdVideoH265HrdParameters,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265SequenceParameterSetVui> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH265SequenceParameterSetVui>(),
         56usize,
@@ -3837,24 +3639,28 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).aspect_ratio_idc
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
             "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio_idc) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265SequenceParameterSetVui),
+            "::",
             stringify!(aspect_ratio_idc)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).sar_width as *const _
-                as usize
-        },
-        2usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize },
+        8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3863,11 +3669,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).sar_height as *const _
-                as usize
-        },
-        4usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize },
+        10usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3876,11 +3679,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).video_format as *const _
-                as usize
-        },
-        6usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize },
+        12usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3889,11 +3689,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).colour_primaries
-                as *const _ as usize
-        },
-        7usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize },
+        13usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3902,11 +3699,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).transfer_characteristics
-                as *const _ as usize
-        },
-        8usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize },
+        14usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3915,11 +3709,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).matrix_coeffs
-                as *const _ as usize
-        },
-        9usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).matrix_coeffs) as usize - ptr as usize },
+        15usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3929,10 +3720,9 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>()))
-                .chroma_sample_loc_type_top_field as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize
         },
-        10usize,
+        16usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3942,10 +3732,9 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>()))
-                .chroma_sample_loc_type_bottom_field as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize
         },
-        11usize,
+        17usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3954,11 +3743,28 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).def_disp_win_left_offset
-                as *const _ as usize
-        },
-        12usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265SequenceParameterSetVui),
+            "::",
+            stringify!(reserved1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
+        19usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265SequenceParameterSetVui),
+            "::",
+            stringify!(reserved2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_left_offset) as usize - ptr as usize },
+        20usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3967,11 +3773,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>()))
-                .def_disp_win_right_offset as *const _ as usize
-        },
-        14usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_right_offset) as usize - ptr as usize },
+        22usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3980,11 +3783,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).def_disp_win_top_offset
-                as *const _ as usize
-        },
-        16usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_top_offset) as usize - ptr as usize },
+        24usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -3993,11 +3793,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>()))
-                .def_disp_win_bottom_offset as *const _ as usize
-        },
-        18usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_bottom_offset) as usize - ptr as usize },
+        26usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -4006,11 +3803,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).vui_num_units_in_tick
-                as *const _ as usize
-        },
-        20usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).vui_num_units_in_tick) as usize - ptr as usize },
+        28usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -4019,11 +3813,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).vui_time_scale
-                as *const _ as usize
-        },
-        24usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).vui_time_scale) as usize - ptr as usize },
+        32usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -4033,10 +3824,9 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>()))
-                .vui_num_ticks_poc_diff_one_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).vui_num_ticks_poc_diff_one_minus1) as usize - ptr as usize
         },
-        28usize,
+        36usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -4046,36 +3836,29 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).hrd_parameters
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).min_spatial_segmentation_idc) as usize - ptr as usize
         },
-        32usize,
+        40usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
             "::",
-            stringify!(hrd_parameters)
+            stringify!(min_spatial_segmentation_idc)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>()))
-                .min_spatial_segmentation_idc as *const _ as usize
-        },
-        40usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
+        42usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
             "::",
-            stringify!(min_spatial_segmentation_idc)
+            stringify!(reserved3)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).max_bytes_per_pic_denom
-                as *const _ as usize
-        },
-        42usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).max_bytes_per_pic_denom) as usize - ptr as usize },
+        44usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -4084,11 +3867,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>()))
-                .max_bits_per_min_cu_denom as *const _ as usize
-        },
-        43usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).max_bits_per_min_cu_denom) as usize - ptr as usize },
+        45usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -4098,10 +3878,9 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>()))
-                .log2_max_mv_length_horizontal as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_max_mv_length_horizontal) as usize - ptr as usize
         },
-        44usize,
+        46usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -4110,11 +3889,8 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>()))
-                .log2_max_mv_length_vertical as *const _ as usize
-        },
-        45usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).log2_max_mv_length_vertical) as usize - ptr as usize },
+        47usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
@@ -4123,26 +3899,26 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSetVui>())).flags as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSetVui),
             "::",
-            stringify!(flags)
+            stringify!(pHrdParameters)
         )
     );
 }
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Debug, Copy, Clone)]
 pub struct StdVideoH265PredictorPaletteEntries {
     pub PredictorPaletteEntries: [[u16; 128usize]; 3usize],
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265PredictorPaletteEntries() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265PredictorPaletteEntries> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH265PredictorPaletteEntries>(),
         768usize,
@@ -4157,10 +3933,7 @@ fn bindgen_test_layout_StdVideoH265PredictorPaletteEntries() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PredictorPaletteEntries>())).PredictorPaletteEntries
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).PredictorPaletteEntries) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -4214,284 +3987,319 @@ impl StdVideoH265SpsFlags {
         }
     }
     #[inline]
-    pub fn scaling_list_enabled_flag(&self) -> u32 {
+    pub fn conformance_window_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_scaling_list_enabled_flag(&mut self, val: u32) {
+    pub fn set_conformance_window_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(2usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn sps_scaling_list_data_present_flag(&self) -> u32 {
+    pub fn sps_sub_layer_ordering_info_present_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_sps_scaling_list_data_present_flag(&mut self, val: u32) {
+    pub fn set_sps_sub_layer_ordering_info_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(3usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn amp_enabled_flag(&self) -> u32 {
+    pub fn scaling_list_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_amp_enabled_flag(&mut self, val: u32) {
+    pub fn set_scaling_list_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(4usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn sample_adaptive_offset_enabled_flag(&self) -> u32 {
+    pub fn sps_scaling_list_data_present_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_sample_adaptive_offset_enabled_flag(&mut self, val: u32) {
+    pub fn set_sps_scaling_list_data_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(5usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn pcm_enabled_flag(&self) -> u32 {
+    pub fn amp_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_pcm_enabled_flag(&mut self, val: u32) {
+    pub fn set_amp_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(6usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn pcm_loop_filter_disabled_flag(&self) -> u32 {
+    pub fn sample_adaptive_offset_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_pcm_loop_filter_disabled_flag(&mut self, val: u32) {
+    pub fn set_sample_adaptive_offset_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(7usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn long_term_ref_pics_present_flag(&self) -> u32 {
+    pub fn pcm_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_long_term_ref_pics_present_flag(&mut self, val: u32) {
+    pub fn set_pcm_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(8usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn sps_temporal_mvp_enabled_flag(&self) -> u32 {
+    pub fn pcm_loop_filter_disabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_sps_temporal_mvp_enabled_flag(&mut self, val: u32) {
+    pub fn set_pcm_loop_filter_disabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(9usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn strong_intra_smoothing_enabled_flag(&self) -> u32 {
+    pub fn long_term_ref_pics_present_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_strong_intra_smoothing_enabled_flag(&mut self, val: u32) {
+    pub fn set_long_term_ref_pics_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(10usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn vui_parameters_present_flag(&self) -> u32 {
+    pub fn sps_temporal_mvp_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_vui_parameters_present_flag(&mut self, val: u32) {
+    pub fn set_sps_temporal_mvp_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(11usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn sps_extension_present_flag(&self) -> u32 {
+    pub fn strong_intra_smoothing_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_sps_extension_present_flag(&mut self, val: u32) {
+    pub fn set_strong_intra_smoothing_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(12usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn sps_range_extension_flag(&self) -> u32 {
+    pub fn vui_parameters_present_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_sps_range_extension_flag(&mut self, val: u32) {
+    pub fn set_vui_parameters_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(13usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn transform_skip_rotation_enabled_flag(&self) -> u32 {
+    pub fn sps_extension_present_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_transform_skip_rotation_enabled_flag(&mut self, val: u32) {
+    pub fn set_sps_extension_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(14usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn transform_skip_context_enabled_flag(&self) -> u32 {
+    pub fn sps_range_extension_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_transform_skip_context_enabled_flag(&mut self, val: u32) {
+    pub fn set_sps_range_extension_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(15usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn implicit_rdpcm_enabled_flag(&self) -> u32 {
+    pub fn transform_skip_rotation_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_implicit_rdpcm_enabled_flag(&mut self, val: u32) {
+    pub fn set_transform_skip_rotation_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(16usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn explicit_rdpcm_enabled_flag(&self) -> u32 {
+    pub fn transform_skip_context_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_explicit_rdpcm_enabled_flag(&mut self, val: u32) {
+    pub fn set_transform_skip_context_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(17usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn extended_precision_processing_flag(&self) -> u32 {
+    pub fn implicit_rdpcm_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_extended_precision_processing_flag(&mut self, val: u32) {
+    pub fn set_implicit_rdpcm_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(18usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn intra_smoothing_disabled_flag(&self) -> u32 {
+    pub fn explicit_rdpcm_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_intra_smoothing_disabled_flag(&mut self, val: u32) {
+    pub fn set_explicit_rdpcm_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(19usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn high_precision_offsets_enabled_flag(&self) -> u32 {
+    pub fn extended_precision_processing_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_high_precision_offsets_enabled_flag(&mut self, val: u32) {
+    pub fn set_extended_precision_processing_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(20usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn persistent_rice_adaptation_enabled_flag(&self) -> u32 {
+    pub fn intra_smoothing_disabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_persistent_rice_adaptation_enabled_flag(&mut self, val: u32) {
+    pub fn set_intra_smoothing_disabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(21usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn cabac_bypass_alignment_enabled_flag(&self) -> u32 {
+    pub fn high_precision_offsets_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_cabac_bypass_alignment_enabled_flag(&mut self, val: u32) {
+    pub fn set_high_precision_offsets_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(22usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 {
+    pub fn persistent_rice_adaptation_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) {
+    pub fn set_persistent_rice_adaptation_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(23usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn palette_mode_enabled_flag(&self) -> u32 {
+    pub fn cabac_bypass_alignment_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_palette_mode_enabled_flag(&mut self, val: u32) {
+    pub fn set_cabac_bypass_alignment_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(24usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn sps_palette_predictor_initializer_present_flag(&self) -> u32 {
+    pub fn sps_scc_extension_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_sps_palette_predictor_initializer_present_flag(&mut self, val: u32) {
+    pub fn set_sps_scc_extension_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(25usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 {
+    pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_intra_boundary_filtering_disabled_flag(&mut self, val: u32) {
+    pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(26usize, 1u8, val as u64)
         }
     }
     #[inline]
+    pub fn palette_mode_enabled_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_palette_mode_enabled_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(27usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn sps_palette_predictor_initializers_present_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_sps_palette_predictor_initializers_present_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(28usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_intra_boundary_filtering_disabled_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(29usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
     pub fn new_bitfield_1(
         sps_temporal_id_nesting_flag: u32,
         separate_colour_plane_flag: u32,
+        conformance_window_flag: u32,
+        sps_sub_layer_ordering_info_present_flag: u32,
         scaling_list_enabled_flag: u32,
         sps_scaling_list_data_present_flag: u32,
         amp_enabled_flag: u32,
@@ -4513,9 +4321,10 @@ impl StdVideoH265SpsFlags {
         high_precision_offsets_enabled_flag: u32,
         persistent_rice_adaptation_enabled_flag: u32,
         cabac_bypass_alignment_enabled_flag: u32,
+        sps_scc_extension_flag: u32,
         sps_curr_pic_ref_enabled_flag: u32,
         palette_mode_enabled_flag: u32,
-        sps_palette_predictor_initializer_present_flag: u32,
+        sps_palette_predictor_initializers_present_flag: u32,
         intra_boundary_filtering_disabled_flag: u32,
     ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
         let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
@@ -4530,124 +4339,139 @@ impl StdVideoH265SpsFlags {
             separate_colour_plane_flag as u64
         });
         __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let conformance_window_flag: u32 =
+                unsafe { ::std::mem::transmute(conformance_window_flag) };
+            conformance_window_flag as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let sps_sub_layer_ordering_info_present_flag: u32 =
+                unsafe { ::std::mem::transmute(sps_sub_layer_ordering_info_present_flag) };
+            sps_sub_layer_ordering_info_present_flag as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
             let scaling_list_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(scaling_list_enabled_flag) };
             scaling_list_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(3usize, 1u8, {
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
             let sps_scaling_list_data_present_flag: u32 =
                 unsafe { ::std::mem::transmute(sps_scaling_list_data_present_flag) };
             sps_scaling_list_data_present_flag as u64
         });
-        __bindgen_bitfield_unit.set(4usize, 1u8, {
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
             let amp_enabled_flag: u32 = unsafe { ::std::mem::transmute(amp_enabled_flag) };
             amp_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(5usize, 1u8, {
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
             let sample_adaptive_offset_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(sample_adaptive_offset_enabled_flag) };
             sample_adaptive_offset_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
+        __bindgen_bitfield_unit.set(8usize, 1u8, {
             let pcm_enabled_flag: u32 = unsafe { ::std::mem::transmute(pcm_enabled_flag) };
             pcm_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(7usize, 1u8, {
+        __bindgen_bitfield_unit.set(9usize, 1u8, {
             let pcm_loop_filter_disabled_flag: u32 =
                 unsafe { ::std::mem::transmute(pcm_loop_filter_disabled_flag) };
             pcm_loop_filter_disabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(8usize, 1u8, {
+        __bindgen_bitfield_unit.set(10usize, 1u8, {
             let long_term_ref_pics_present_flag: u32 =
                 unsafe { ::std::mem::transmute(long_term_ref_pics_present_flag) };
             long_term_ref_pics_present_flag as u64
         });
-        __bindgen_bitfield_unit.set(9usize, 1u8, {
+        __bindgen_bitfield_unit.set(11usize, 1u8, {
             let sps_temporal_mvp_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(sps_temporal_mvp_enabled_flag) };
             sps_temporal_mvp_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(10usize, 1u8, {
+        __bindgen_bitfield_unit.set(12usize, 1u8, {
             let strong_intra_smoothing_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(strong_intra_smoothing_enabled_flag) };
             strong_intra_smoothing_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(11usize, 1u8, {
+        __bindgen_bitfield_unit.set(13usize, 1u8, {
             let vui_parameters_present_flag: u32 =
                 unsafe { ::std::mem::transmute(vui_parameters_present_flag) };
             vui_parameters_present_flag as u64
         });
-        __bindgen_bitfield_unit.set(12usize, 1u8, {
+        __bindgen_bitfield_unit.set(14usize, 1u8, {
             let sps_extension_present_flag: u32 =
                 unsafe { ::std::mem::transmute(sps_extension_present_flag) };
             sps_extension_present_flag as u64
         });
-        __bindgen_bitfield_unit.set(13usize, 1u8, {
+        __bindgen_bitfield_unit.set(15usize, 1u8, {
             let sps_range_extension_flag: u32 =
                 unsafe { ::std::mem::transmute(sps_range_extension_flag) };
             sps_range_extension_flag as u64
         });
-        __bindgen_bitfield_unit.set(14usize, 1u8, {
+        __bindgen_bitfield_unit.set(16usize, 1u8, {
             let transform_skip_rotation_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(transform_skip_rotation_enabled_flag) };
             transform_skip_rotation_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(15usize, 1u8, {
+        __bindgen_bitfield_unit.set(17usize, 1u8, {
             let transform_skip_context_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(transform_skip_context_enabled_flag) };
             transform_skip_context_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(16usize, 1u8, {
+        __bindgen_bitfield_unit.set(18usize, 1u8, {
             let implicit_rdpcm_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(implicit_rdpcm_enabled_flag) };
             implicit_rdpcm_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(17usize, 1u8, {
+        __bindgen_bitfield_unit.set(19usize, 1u8, {
             let explicit_rdpcm_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(explicit_rdpcm_enabled_flag) };
             explicit_rdpcm_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(18usize, 1u8, {
+        __bindgen_bitfield_unit.set(20usize, 1u8, {
             let extended_precision_processing_flag: u32 =
                 unsafe { ::std::mem::transmute(extended_precision_processing_flag) };
             extended_precision_processing_flag as u64
         });
-        __bindgen_bitfield_unit.set(19usize, 1u8, {
+        __bindgen_bitfield_unit.set(21usize, 1u8, {
             let intra_smoothing_disabled_flag: u32 =
                 unsafe { ::std::mem::transmute(intra_smoothing_disabled_flag) };
             intra_smoothing_disabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(20usize, 1u8, {
+        __bindgen_bitfield_unit.set(22usize, 1u8, {
             let high_precision_offsets_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(high_precision_offsets_enabled_flag) };
             high_precision_offsets_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(21usize, 1u8, {
+        __bindgen_bitfield_unit.set(23usize, 1u8, {
             let persistent_rice_adaptation_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(persistent_rice_adaptation_enabled_flag) };
             persistent_rice_adaptation_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(22usize, 1u8, {
+        __bindgen_bitfield_unit.set(24usize, 1u8, {
             let cabac_bypass_alignment_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(cabac_bypass_alignment_enabled_flag) };
             cabac_bypass_alignment_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(23usize, 1u8, {
+        __bindgen_bitfield_unit.set(25usize, 1u8, {
+            let sps_scc_extension_flag: u32 =
+                unsafe { ::std::mem::transmute(sps_scc_extension_flag) };
+            sps_scc_extension_flag as u64
+        });
+        __bindgen_bitfield_unit.set(26usize, 1u8, {
             let sps_curr_pic_ref_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(sps_curr_pic_ref_enabled_flag) };
             sps_curr_pic_ref_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(24usize, 1u8, {
+        __bindgen_bitfield_unit.set(27usize, 1u8, {
             let palette_mode_enabled_flag: u32 =
                 unsafe { ::std::mem::transmute(palette_mode_enabled_flag) };
             palette_mode_enabled_flag as u64
         });
-        __bindgen_bitfield_unit.set(25usize, 1u8, {
-            let sps_palette_predictor_initializer_present_flag: u32 =
-                unsafe { ::std::mem::transmute(sps_palette_predictor_initializer_present_flag) };
-            sps_palette_predictor_initializer_present_flag as u64
+        __bindgen_bitfield_unit.set(28usize, 1u8, {
+            let sps_palette_predictor_initializers_present_flag: u32 =
+                unsafe { ::std::mem::transmute(sps_palette_predictor_initializers_present_flag) };
+            sps_palette_predictor_initializers_present_flag as u64
         });
-        __bindgen_bitfield_unit.set(26usize, 1u8, {
+        __bindgen_bitfield_unit.set(29usize, 1u8, {
             let intra_boundary_filtering_disabled_flag: u32 =
                 unsafe { ::std::mem::transmute(intra_boundary_filtering_disabled_flag) };
             intra_boundary_filtering_disabled_flag as u64
@@ -4656,20 +4480,301 @@ impl StdVideoH265SpsFlags {
     }
 }
 #[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoH265ShortTermRefPicSetFlags {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoH265ShortTermRefPicSetFlags() {
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoH265ShortTermRefPicSetFlags>(),
+        4usize,
+        concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSetFlags))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoH265ShortTermRefPicSetFlags>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoH265ShortTermRefPicSetFlags)
+        )
+    );
+}
+impl StdVideoH265ShortTermRefPicSetFlags {
+    #[inline]
+    pub fn inter_ref_pic_set_prediction_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_inter_ref_pic_set_prediction_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn delta_rps_sign(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_delta_rps_sign(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        inter_ref_pic_set_prediction_flag: u32,
+        delta_rps_sign: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let inter_ref_pic_set_prediction_flag: u32 =
+                unsafe { ::std::mem::transmute(inter_ref_pic_set_prediction_flag) };
+            inter_ref_pic_set_prediction_flag as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let delta_rps_sign: u32 = unsafe { ::std::mem::transmute(delta_rps_sign) };
+            delta_rps_sign as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoH265ShortTermRefPicSet {
+    pub flags: StdVideoH265ShortTermRefPicSetFlags,
+    pub delta_idx_minus1: u32,
+    pub use_delta_flag: u16,
+    pub abs_delta_rps_minus1: u16,
+    pub used_by_curr_pic_flag: u16,
+    pub used_by_curr_pic_s0_flag: u16,
+    pub used_by_curr_pic_s1_flag: u16,
+    pub reserved1: u16,
+    pub reserved2: u8,
+    pub reserved3: u8,
+    pub num_negative_pics: u8,
+    pub num_positive_pics: u8,
+    pub delta_poc_s0_minus1: [u16; 16usize],
+    pub delta_poc_s1_minus1: [u16; 16usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoH265ShortTermRefPicSet() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265ShortTermRefPicSet> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoH265ShortTermRefPicSet>(),
+        88usize,
+        concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSet))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoH265ShortTermRefPicSet>(),
+        4usize,
+        concat!("Alignment of ", stringify!(StdVideoH265ShortTermRefPicSet))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_idx_minus1) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(delta_idx_minus1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).use_delta_flag) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(use_delta_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).abs_delta_rps_minus1) as usize - ptr as usize },
+        10usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(abs_delta_rps_minus1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_flag) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(used_by_curr_pic_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s0_flag) as usize - ptr as usize },
+        14usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(used_by_curr_pic_s0_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s1_flag) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(used_by_curr_pic_s1_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(reserved1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
+        20usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(reserved2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
+        21usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(reserved3)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).num_negative_pics) as usize - ptr as usize },
+        22usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(num_negative_pics)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).num_positive_pics) as usize - ptr as usize },
+        23usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(num_positive_pics)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s0_minus1) as usize - ptr as usize },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(delta_poc_s0_minus1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s1_minus1) as usize - ptr as usize },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265ShortTermRefPicSet),
+            "::",
+            stringify!(delta_poc_s1_minus1)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoH265LongTermRefPicsSps {
+    pub used_by_curr_pic_lt_sps_flag: u32,
+    pub lt_ref_pic_poc_lsb_sps: [u32; 32usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoH265LongTermRefPicsSps() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265LongTermRefPicsSps> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoH265LongTermRefPicsSps>(),
+        132usize,
+        concat!("Size of: ", stringify!(StdVideoH265LongTermRefPicsSps))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoH265LongTermRefPicsSps>(),
+        4usize,
+        concat!("Alignment of ", stringify!(StdVideoH265LongTermRefPicsSps))
+    );
+    assert_eq!(
+        unsafe {
+            ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_sps_flag) as usize - ptr as usize
+        },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265LongTermRefPicsSps),
+            "::",
+            stringify!(used_by_curr_pic_lt_sps_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lt_ref_pic_poc_lsb_sps) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265LongTermRefPicsSps),
+            "::",
+            stringify!(lt_ref_pic_poc_lsb_sps)
+        )
+    );
+}
+#[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH265SequenceParameterSet {
-    pub profile_idc: StdVideoH265ProfileIdc,
-    pub level_idc: StdVideoH265Level,
+    pub flags: StdVideoH265SpsFlags,
+    pub chroma_format_idc: StdVideoH265ChromaFormatIdc,
     pub pic_width_in_luma_samples: u32,
     pub pic_height_in_luma_samples: u32,
     pub sps_video_parameter_set_id: u8,
     pub sps_max_sub_layers_minus1: u8,
     pub sps_seq_parameter_set_id: u8,
-    pub chroma_format_idc: u8,
     pub bit_depth_luma_minus8: u8,
     pub bit_depth_chroma_minus8: u8,
     pub log2_max_pic_order_cnt_lsb_minus4: u8,
-    pub sps_max_dec_pic_buffering_minus1: u8,
     pub log2_min_luma_coding_block_size_minus3: u8,
     pub log2_diff_max_min_luma_coding_block_size: u8,
     pub log2_min_luma_transform_block_size_minus2: u8,
@@ -4682,25 +4787,32 @@ pub struct StdVideoH265SequenceParameterSet {
     pub pcm_sample_bit_depth_chroma_minus1: u8,
     pub log2_min_pcm_luma_coding_block_size_minus3: u8,
     pub log2_diff_max_min_pcm_luma_coding_block_size: u8,
+    pub reserved1: u8,
+    pub reserved2: u8,
+    pub palette_max_size: u8,
+    pub delta_palette_max_predictor_size: u8,
+    pub motion_vector_resolution_control_idc: u8,
+    pub sps_num_palette_predictor_initializers_minus1: u8,
     pub conf_win_left_offset: u32,
     pub conf_win_right_offset: u32,
     pub conf_win_top_offset: u32,
     pub conf_win_bottom_offset: u32,
-    pub pDecPicBufMgr: *mut StdVideoH265DecPicBufMgr,
-    pub flags: StdVideoH265SpsFlags,
-    pub pScalingLists: *mut StdVideoH265ScalingLists,
-    pub pSequenceParameterSetVui: *mut StdVideoH265SequenceParameterSetVui,
-    pub palette_max_size: u8,
-    pub delta_palette_max_predictor_size: u8,
-    pub motion_vector_resolution_control_idc: u8,
-    pub sps_num_palette_predictor_initializer_minus1: u8,
-    pub pPredictorPaletteEntries: *mut StdVideoH265PredictorPaletteEntries,
+    pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel,
+    pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr,
+    pub pScalingLists: *const StdVideoH265ScalingLists,
+    pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet,
+    pub pLongTermRefPicsSps: *const StdVideoH265LongTermRefPicsSps,
+    pub pSequenceParameterSetVui: *const StdVideoH265SequenceParameterSetVui,
+    pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265SequenceParameterSet() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265SequenceParameterSet> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH265SequenceParameterSet>(),
-        104usize,
+        112usize,
         concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSet))
     );
     assert_eq!(
@@ -4712,36 +4824,27 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).profile_idc as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(profile_idc)
+            stringify!(flags)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).level_idc as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(level_idc)
+            stringify!(chroma_format_idc)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).pic_width_in_luma_samples
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_luma_samples) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -4751,10 +4854,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).pic_height_in_luma_samples
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pic_height_in_luma_samples) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -4764,10 +4864,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).sps_video_parameter_set_id
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -4777,10 +4874,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).sps_max_sub_layers_minus1
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).sps_max_sub_layers_minus1) as usize - ptr as usize },
         17usize,
         concat!(
             "Offset of field: ",
@@ -4790,10 +4884,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).sps_seq_parameter_set_id
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).sps_seq_parameter_set_id) as usize - ptr as usize },
         18usize,
         concat!(
             "Offset of field: ",
@@ -4803,391 +4894,358 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).chroma_format_idc
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize },
         19usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(chroma_format_idc)
+            stringify!(bit_depth_luma_minus8)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).bit_depth_luma_minus8
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(bit_depth_luma_minus8)
+            stringify!(bit_depth_chroma_minus8)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).bit_depth_chroma_minus8
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize
         },
         21usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(bit_depth_chroma_minus8)
+            stringify!(log2_max_pic_order_cnt_lsb_minus4)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .log2_max_pic_order_cnt_lsb_minus4 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_min_luma_coding_block_size_minus3) as usize
+                - ptr as usize
         },
         22usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(log2_max_pic_order_cnt_lsb_minus4)
+            stringify!(log2_min_luma_coding_block_size_minus3)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .sps_max_dec_pic_buffering_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_coding_block_size) as usize
+                - ptr as usize
         },
         23usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(sps_max_dec_pic_buffering_minus1)
+            stringify!(log2_diff_max_min_luma_coding_block_size)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .log2_min_luma_coding_block_size_minus3 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_min_luma_transform_block_size_minus2) as usize
+                - ptr as usize
         },
         24usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(log2_min_luma_coding_block_size_minus3)
+            stringify!(log2_min_luma_transform_block_size_minus2)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .log2_diff_max_min_luma_coding_block_size as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_transform_block_size) as usize
+                - ptr as usize
         },
         25usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(log2_diff_max_min_luma_coding_block_size)
+            stringify!(log2_diff_max_min_luma_transform_block_size)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .log2_min_luma_transform_block_size_minus2 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_inter) as usize - ptr as usize
         },
         26usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(log2_min_luma_transform_block_size_minus2)
+            stringify!(max_transform_hierarchy_depth_inter)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .log2_diff_max_min_luma_transform_block_size as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_intra) as usize - ptr as usize
         },
         27usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(log2_diff_max_min_luma_transform_block_size)
+            stringify!(max_transform_hierarchy_depth_intra)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .max_transform_hierarchy_depth_inter as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).num_short_term_ref_pic_sets) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(max_transform_hierarchy_depth_inter)
+            stringify!(num_short_term_ref_pic_sets)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .max_transform_hierarchy_depth_intra as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_ref_pics_sps) as usize - ptr as usize },
         29usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(max_transform_hierarchy_depth_intra)
+            stringify!(num_long_term_ref_pics_sps)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).num_short_term_ref_pic_sets
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_luma_minus1) as usize - ptr as usize
         },
         30usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(num_short_term_ref_pic_sets)
+            stringify!(pcm_sample_bit_depth_luma_minus1)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).num_long_term_ref_pics_sps
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_chroma_minus1) as usize - ptr as usize
         },
         31usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(num_long_term_ref_pics_sps)
+            stringify!(pcm_sample_bit_depth_chroma_minus1)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .pcm_sample_bit_depth_luma_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_min_pcm_luma_coding_block_size_minus3) as usize
+                - ptr as usize
         },
         32usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(pcm_sample_bit_depth_luma_minus1)
+            stringify!(log2_min_pcm_luma_coding_block_size_minus3)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .pcm_sample_bit_depth_chroma_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_diff_max_min_pcm_luma_coding_block_size) as usize
+                - ptr as usize
         },
         33usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(pcm_sample_bit_depth_chroma_minus1)
+            stringify!(log2_diff_max_min_pcm_luma_coding_block_size)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .log2_min_pcm_luma_coding_block_size_minus3 as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
         34usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(log2_min_pcm_luma_coding_block_size_minus3)
+            stringify!(reserved1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .log2_diff_max_min_pcm_luma_coding_block_size as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
         35usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(log2_diff_max_min_pcm_luma_coding_block_size)
+            stringify!(reserved2)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).conf_win_left_offset
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).palette_max_size) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(conf_win_left_offset)
+            stringify!(palette_max_size)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).conf_win_right_offset
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).delta_palette_max_predictor_size) as usize - ptr as usize
         },
-        40usize,
+        37usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(conf_win_right_offset)
+            stringify!(delta_palette_max_predictor_size)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).conf_win_top_offset
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).motion_vector_resolution_control_idc) as usize
+                - ptr as usize
         },
-        44usize,
+        38usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(conf_win_top_offset)
+            stringify!(motion_vector_resolution_control_idc)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).conf_win_bottom_offset
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).sps_num_palette_predictor_initializers_minus1) as usize
+                - ptr as usize
         },
-        48usize,
+        39usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(conf_win_bottom_offset)
+            stringify!(sps_num_palette_predictor_initializers_minus1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).pDecPicBufMgr as *const _
-                as usize
-        },
-        56usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).conf_win_left_offset) as usize - ptr as usize },
+        40usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(pDecPicBufMgr)
+            stringify!(conf_win_left_offset)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).flags as *const _ as usize
-        },
-        64usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).conf_win_right_offset) as usize - ptr as usize },
+        44usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(flags)
+            stringify!(conf_win_right_offset)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).pScalingLists as *const _
-                as usize
-        },
-        72usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).conf_win_top_offset) as usize - ptr as usize },
+        48usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(pScalingLists)
+            stringify!(conf_win_top_offset)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).pSequenceParameterSetVui
-                as *const _ as usize
-        },
-        80usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).conf_win_bottom_offset) as usize - ptr as usize },
+        52usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(pSequenceParameterSetVui)
+            stringify!(conf_win_bottom_offset)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).palette_max_size
-                as *const _ as usize
-        },
-        88usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize },
+        56usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(palette_max_size)
+            stringify!(pProfileTierLevel)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .delta_palette_max_predictor_size as *const _ as usize
-        },
-        89usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize },
+        64usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(delta_palette_max_predictor_size)
+            stringify!(pDecPicBufMgr)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .motion_vector_resolution_control_idc as *const _ as usize
-        },
-        90usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
+        72usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(motion_vector_resolution_control_idc)
+            stringify!(pScalingLists)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>()))
-                .sps_num_palette_predictor_initializer_minus1 as *const _ as usize
-        },
-        91usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize },
+        80usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
-            stringify!(sps_num_palette_predictor_initializer_minus1)
+            stringify!(pShortTermRefPicSet)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265SequenceParameterSet>())).pPredictorPaletteEntries
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPicsSps) as usize - ptr as usize },
+        88usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265SequenceParameterSet),
+            "::",
+            stringify!(pLongTermRefPicsSps)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize },
         96usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265SequenceParameterSet),
             "::",
+            stringify!(pSequenceParameterSetVui)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize },
+        104usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265SequenceParameterSet),
+            "::",
             stringify!(pPredictorPaletteEntries)
         )
     );
@@ -5522,11 +5580,11 @@ impl StdVideoH265PpsFlags {
         }
     }
     #[inline]
-    pub fn pps_palette_predictor_initializer_present_flag(&self) -> u32 {
+    pub fn pps_palette_predictor_initializers_present_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_pps_palette_predictor_initializer_present_flag(&mut self, val: u32) {
+    pub fn set_pps_palette_predictor_initializers_present_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(28usize, 1u8, val as u64)
@@ -5584,7 +5642,7 @@ impl StdVideoH265PpsFlags {
         pps_curr_pic_ref_enabled_flag: u32,
         residual_adaptive_colour_transform_enabled_flag: u32,
         pps_slice_act_qp_offsets_present_flag: u32,
-        pps_palette_predictor_initializer_present_flag: u32,
+        pps_palette_predictor_initializers_present_flag: u32,
         monochrome_palette_flag: u32,
         pps_range_extension_flag: u32,
     ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
@@ -5726,9 +5784,9 @@ impl StdVideoH265PpsFlags {
             pps_slice_act_qp_offsets_present_flag as u64
         });
         __bindgen_bitfield_unit.set(28usize, 1u8, {
-            let pps_palette_predictor_initializer_present_flag: u32 =
-                unsafe { ::std::mem::transmute(pps_palette_predictor_initializer_present_flag) };
-            pps_palette_predictor_initializer_present_flag as u64
+            let pps_palette_predictor_initializers_present_flag: u32 =
+                unsafe { ::std::mem::transmute(pps_palette_predictor_initializers_present_flag) };
+            pps_palette_predictor_initializers_present_flag as u64
         });
         __bindgen_bitfield_unit.set(29usize, 1u8, {
             let monochrome_palette_flag: u32 =
@@ -5746,8 +5804,10 @@ impl StdVideoH265PpsFlags {
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoH265PictureParameterSet {
+    pub flags: StdVideoH265PpsFlags,
     pub pps_pic_parameter_set_id: u8,
     pub pps_seq_parameter_set_id: u8,
+    pub sps_video_parameter_set_id: u8,
     pub num_extra_slice_header_bits: u8,
     pub num_ref_idx_l0_default_active_minus1: u8,
     pub num_ref_idx_l1_default_active_minus1: u8,
@@ -5755,15 +5815,9 @@ pub struct StdVideoH265PictureParameterSet {
     pub diff_cu_qp_delta_depth: u8,
     pub pps_cb_qp_offset: i8,
     pub pps_cr_qp_offset: i8,
-    pub num_tile_columns_minus1: u8,
-    pub num_tile_rows_minus1: u8,
-    pub column_width_minus1: [u16; 19usize],
-    pub row_height_minus1: [u16; 21usize],
     pub pps_beta_offset_div2: i8,
     pub pps_tc_offset_div2: i8,
     pub log2_parallel_merge_level_minus2: u8,
-    pub flags: StdVideoH265PpsFlags,
-    pub pScalingLists: *mut StdVideoH265ScalingLists,
     pub log2_max_transform_skip_block_size_minus2: u8,
     pub diff_cu_chroma_qp_offset_depth: u8,
     pub chroma_qp_offset_list_len_minus1: u8,
@@ -5773,14 +5827,25 @@ pub struct StdVideoH265PictureParameterSet {
     pub log2_sao_offset_scale_chroma: u8,
     pub pps_act_y_qp_offset_plus5: i8,
     pub pps_act_cb_qp_offset_plus5: i8,
-    pub pps_act_cr_qp_offset_plus5: i8,
-    pub pps_num_palette_predictor_initializer: u8,
+    pub pps_act_cr_qp_offset_plus3: i8,
+    pub pps_num_palette_predictor_initializers: u8,
     pub luma_bit_depth_entry_minus8: u8,
     pub chroma_bit_depth_entry_minus8: u8,
-    pub pPredictorPaletteEntries: *mut StdVideoH265PredictorPaletteEntries,
+    pub num_tile_columns_minus1: u8,
+    pub num_tile_rows_minus1: u8,
+    pub reserved1: u8,
+    pub reserved2: u8,
+    pub column_width_minus1: [u16; 19usize],
+    pub row_height_minus1: [u16; 21usize],
+    pub reserved3: u32,
+    pub pScalingLists: *const StdVideoH265ScalingLists,
+    pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries,
 }
 #[test]
 fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoH265PictureParameterSet> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoH265PictureParameterSet>(),
         144usize,
@@ -5792,24 +5857,28 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
         concat!("Alignment of ", stringify!(StdVideoH265PictureParameterSet))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pps_pic_parameter_set_id
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265PictureParameterSet),
+            "::",
             stringify!(pps_pic_parameter_set_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pps_seq_parameter_set_id
-                as *const _ as usize
-        },
-        1usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
+        5usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
@@ -5818,11 +5887,18 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).num_extra_slice_header_bits
-                as *const _ as usize
-        },
-        2usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265PictureParameterSet),
+            "::",
+            stringify!(sps_video_parameter_set_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).num_extra_slice_header_bits) as usize - ptr as usize },
+        7usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
@@ -5832,10 +5908,10 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>()))
-                .num_ref_idx_l0_default_active_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize
+                - ptr as usize
         },
-        3usize,
+        8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
@@ -5845,10 +5921,10 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>()))
-                .num_ref_idx_l1_default_active_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize
+                - ptr as usize
         },
-        4usize,
+        9usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
@@ -5857,11 +5933,8 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).init_qp_minus26 as *const _
-                as usize
-        },
-        5usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).init_qp_minus26) as usize - ptr as usize },
+        10usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
@@ -5870,11 +5943,8 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).diff_cu_qp_delta_depth
-                as *const _ as usize
-        },
-        6usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).diff_cu_qp_delta_depth) as usize - ptr as usize },
+        11usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
@@ -5883,11 +5953,8 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pps_cb_qp_offset as *const _
-                as usize
-        },
-        7usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_cb_qp_offset) as usize - ptr as usize },
+        12usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
@@ -5896,11 +5963,8 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pps_cr_qp_offset as *const _
-                as usize
-        },
-        8usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_cr_qp_offset) as usize - ptr as usize },
+        13usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
@@ -5909,295 +5973,263 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).num_tile_columns_minus1
-                as *const _ as usize
-        },
-        9usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_beta_offset_div2) as usize - ptr as usize },
+        14usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(num_tile_columns_minus1)
+            stringify!(pps_beta_offset_div2)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).num_tile_rows_minus1
-                as *const _ as usize
-        },
-        10usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_tc_offset_div2) as usize - ptr as usize },
+        15usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(num_tile_rows_minus1)
+            stringify!(pps_tc_offset_div2)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).column_width_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_parallel_merge_level_minus2) as usize - ptr as usize
         },
-        12usize,
+        16usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(column_width_minus1)
+            stringify!(log2_parallel_merge_level_minus2)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).row_height_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_max_transform_skip_block_size_minus2) as usize
+                - ptr as usize
         },
-        50usize,
+        17usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(row_height_minus1)
+            stringify!(log2_max_transform_skip_block_size_minus2)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pps_beta_offset_div2
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).diff_cu_chroma_qp_offset_depth) as usize - ptr as usize
         },
-        92usize,
+        18usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(pps_beta_offset_div2)
+            stringify!(diff_cu_chroma_qp_offset_depth)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pps_tc_offset_div2
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).chroma_qp_offset_list_len_minus1) as usize - ptr as usize
         },
-        93usize,
+        19usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(pps_tc_offset_div2)
+            stringify!(chroma_qp_offset_list_len_minus1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>()))
-                .log2_parallel_merge_level_minus2 as *const _ as usize
-        },
-        94usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).cb_qp_offset_list) as usize - ptr as usize },
+        20usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(log2_parallel_merge_level_minus2)
+            stringify!(cb_qp_offset_list)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).flags as *const _ as usize
-        },
-        96usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).cr_qp_offset_list) as usize - ptr as usize },
+        26usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(flags)
+            stringify!(cr_qp_offset_list)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pScalingLists as *const _
-                as usize
-        },
-        104usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_luma) as usize - ptr as usize },
+        32usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(pScalingLists)
+            stringify!(log2_sao_offset_scale_luma)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>()))
-                .log2_max_transform_skip_block_size_minus2 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_chroma) as usize - ptr as usize
         },
-        112usize,
+        33usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(log2_max_transform_skip_block_size_minus2)
+            stringify!(log2_sao_offset_scale_chroma)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>()))
-                .diff_cu_chroma_qp_offset_depth as *const _ as usize
-        },
-        113usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_act_y_qp_offset_plus5) as usize - ptr as usize },
+        34usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(diff_cu_chroma_qp_offset_depth)
+            stringify!(pps_act_y_qp_offset_plus5)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>()))
-                .chroma_qp_offset_list_len_minus1 as *const _ as usize
-        },
-        114usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cb_qp_offset_plus5) as usize - ptr as usize },
+        35usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(chroma_qp_offset_list_len_minus1)
+            stringify!(pps_act_cb_qp_offset_plus5)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).cb_qp_offset_list
-                as *const _ as usize
-        },
-        115usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cr_qp_offset_plus3) as usize - ptr as usize },
+        36usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(cb_qp_offset_list)
+            stringify!(pps_act_cr_qp_offset_plus3)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).cr_qp_offset_list
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).pps_num_palette_predictor_initializers) as usize
+                - ptr as usize
         },
-        121usize,
+        37usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(cr_qp_offset_list)
+            stringify!(pps_num_palette_predictor_initializers)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).log2_sao_offset_scale_luma
-                as *const _ as usize
-        },
-        127usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_bit_depth_entry_minus8) as usize - ptr as usize },
+        38usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(log2_sao_offset_scale_luma)
+            stringify!(luma_bit_depth_entry_minus8)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).log2_sao_offset_scale_chroma
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).chroma_bit_depth_entry_minus8) as usize - ptr as usize
         },
-        128usize,
+        39usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(log2_sao_offset_scale_chroma)
+            stringify!(chroma_bit_depth_entry_minus8)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pps_act_y_qp_offset_plus5
-                as *const _ as usize
-        },
-        129usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).num_tile_columns_minus1) as usize - ptr as usize },
+        40usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(pps_act_y_qp_offset_plus5)
+            stringify!(num_tile_columns_minus1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pps_act_cb_qp_offset_plus5
-                as *const _ as usize
-        },
-        130usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).num_tile_rows_minus1) as usize - ptr as usize },
+        41usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(pps_act_cb_qp_offset_plus5)
+            stringify!(num_tile_rows_minus1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pps_act_cr_qp_offset_plus5
-                as *const _ as usize
-        },
-        131usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        42usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(pps_act_cr_qp_offset_plus5)
+            stringify!(reserved1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>()))
-                .pps_num_palette_predictor_initializer as *const _ as usize
-        },
-        132usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
+        43usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(pps_num_palette_predictor_initializer)
+            stringify!(reserved2)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).luma_bit_depth_entry_minus8
-                as *const _ as usize
-        },
-        133usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).column_width_minus1) as usize - ptr as usize },
+        44usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(luma_bit_depth_entry_minus8)
+            stringify!(column_width_minus1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>()))
-                .chroma_bit_depth_entry_minus8 as *const _ as usize
-        },
-        134usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).row_height_minus1) as usize - ptr as usize },
+        82usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoH265PictureParameterSet),
             "::",
-            stringify!(chroma_bit_depth_entry_minus8)
+            stringify!(row_height_minus1)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoH265PictureParameterSet>())).pPredictorPaletteEntries
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
+        124usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265PictureParameterSet),
+            "::",
+            stringify!(reserved3)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
+        128usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoH265PictureParameterSet),
+            "::",
+            stringify!(pScalingLists)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize },
         136usize,
         concat!(
             "Offset of field: ",
@@ -6307,20 +6339,23 @@ impl StdVideoDecodeH265PictureInfoFlags {
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoDecodeH265PictureInfo {
-    pub vps_video_parameter_set_id: u8,
-    pub sps_seq_parameter_set_id: u8,
+    pub flags: StdVideoDecodeH265PictureInfoFlags,
+    pub sps_video_parameter_set_id: u8,
+    pub pps_seq_parameter_set_id: u8,
     pub pps_pic_parameter_set_id: u8,
-    pub num_short_term_ref_pic_sets: u8,
+    pub NumDeltaPocsOfRefRpsIdx: u8,
     pub PicOrderCntVal: i32,
     pub NumBitsForSTRefPicSetInSlice: u16,
-    pub NumDeltaPocsOfRefRpsIdx: u8,
+    pub reserved: u16,
     pub RefPicSetStCurrBefore: [u8; 8usize],
     pub RefPicSetStCurrAfter: [u8; 8usize],
     pub RefPicSetLtCurr: [u8; 8usize],
-    pub flags: StdVideoDecodeH265PictureInfoFlags,
 }
 #[test]
 fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoDecodeH265PictureInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoDecodeH265PictureInfo>(),
         40usize,
@@ -6332,145 +6367,115 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() {
         concat!("Alignment of ", stringify!(StdVideoDecodeH265PictureInfo))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).vps_video_parameter_set_id
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(vps_video_parameter_set_id)
+            stringify!(flags)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).sps_seq_parameter_set_id
-                as *const _ as usize
-        },
-        1usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
+        4usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(sps_seq_parameter_set_id)
+            stringify!(sps_video_parameter_set_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).pps_pic_parameter_set_id
-                as *const _ as usize
-        },
-        2usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
+        5usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(pps_pic_parameter_set_id)
+            stringify!(pps_seq_parameter_set_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).num_short_term_ref_pic_sets
-                as *const _ as usize
-        },
-        3usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
+        6usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(num_short_term_ref_pic_sets)
+            stringify!(pps_pic_parameter_set_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).PicOrderCntVal as *const _
-                as usize
-        },
-        4usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).NumDeltaPocsOfRefRpsIdx) as usize - ptr as usize },
+        7usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(PicOrderCntVal)
+            stringify!(NumDeltaPocsOfRefRpsIdx)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).NumBitsForSTRefPicSetInSlice
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(NumBitsForSTRefPicSetInSlice)
+            stringify!(PicOrderCntVal)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).NumDeltaPocsOfRefRpsIdx
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).NumBitsForSTRefPicSetInSlice) as usize - ptr as usize
         },
-        10usize,
+        12usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(NumDeltaPocsOfRefRpsIdx)
+            stringify!(NumBitsForSTRefPicSetInSlice)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).RefPicSetStCurrBefore
-                as *const _ as usize
-        },
-        11usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
+        14usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(RefPicSetStCurrBefore)
+            stringify!(reserved)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).RefPicSetStCurrAfter
-                as *const _ as usize
-        },
-        19usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrBefore) as usize - ptr as usize },
+        16usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(RefPicSetStCurrAfter)
+            stringify!(RefPicSetStCurrBefore)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).RefPicSetLtCurr as *const _
-                as usize
-        },
-        27usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrAfter) as usize - ptr as usize },
+        24usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(RefPicSetLtCurr)
+            stringify!(RefPicSetStCurrAfter)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265PictureInfo>())).flags as *const _ as usize
-        },
-        36usize,
+        unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetLtCurr) as usize - ptr as usize },
+        32usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265PictureInfo),
             "::",
-            stringify!(flags)
+            stringify!(RefPicSetLtCurr)
         )
     );
 }
@@ -6503,22 +6508,22 @@ fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfoFlags() {
 }
 impl StdVideoDecodeH265ReferenceInfoFlags {
     #[inline]
-    pub fn is_long_term(&self) -> u32 {
+    pub fn used_for_long_term_reference(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_is_long_term(&mut self, val: u32) {
+    pub fn set_used_for_long_term_reference(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(0usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn is_non_existing(&self) -> u32 {
+    pub fn unused_for_reference(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_is_non_existing(&mut self, val: u32) {
+    pub fn set_unused_for_reference(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(1usize, 1u8, val as u64)
@@ -6526,17 +6531,18 @@ impl StdVideoDecodeH265ReferenceInfoFlags {
     }
     #[inline]
     pub fn new_bitfield_1(
-        is_long_term: u32,
-        is_non_existing: u32,
+        used_for_long_term_reference: u32,
+        unused_for_reference: u32,
     ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
         let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
         __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let is_long_term: u32 = unsafe { ::std::mem::transmute(is_long_term) };
-            is_long_term as u64
+            let used_for_long_term_reference: u32 =
+                unsafe { ::std::mem::transmute(used_for_long_term_reference) };
+            used_for_long_term_reference as u64
         });
         __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let is_non_existing: u32 = unsafe { ::std::mem::transmute(is_non_existing) };
-            is_non_existing as u64
+            let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) };
+            unused_for_reference as u64
         });
         __bindgen_bitfield_unit
     }
@@ -6544,11 +6550,14 @@ impl StdVideoDecodeH265ReferenceInfoFlags {
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoDecodeH265ReferenceInfo {
-    pub PicOrderCntVal: i32,
     pub flags: StdVideoDecodeH265ReferenceInfoFlags,
+    pub PicOrderCntVal: i32,
 }
 #[test]
 fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoDecodeH265ReferenceInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoDecodeH265ReferenceInfo>(),
         8usize,
@@ -6560,30 +6569,233 @@ fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfo() {
         concat!("Alignment of ", stringify!(StdVideoDecodeH265ReferenceInfo))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265ReferenceInfo>())).PicOrderCntVal as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265ReferenceInfo),
             "::",
-            stringify!(PicOrderCntVal)
+            stringify!(flags)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoDecodeH265ReferenceInfo>())).flags as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoDecodeH265ReferenceInfo),
             "::",
+            stringify!(PicOrderCntVal)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH264WeightTableFlags {
+    pub luma_weight_l0_flag: u32,
+    pub chroma_weight_l0_flag: u32,
+    pub luma_weight_l1_flag: u32,
+    pub chroma_weight_l1_flag: u32,
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH264WeightTableFlags() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264WeightTableFlags> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH264WeightTableFlags>(),
+        16usize,
+        concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTableFlags))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH264WeightTableFlags>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH264WeightTableFlags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTableFlags),
+            "::",
+            stringify!(luma_weight_l0_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTableFlags),
+            "::",
+            stringify!(chroma_weight_l0_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTableFlags),
+            "::",
+            stringify!(luma_weight_l1_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTableFlags),
+            "::",
+            stringify!(chroma_weight_l1_flag)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH264WeightTable {
+    pub flags: StdVideoEncodeH264WeightTableFlags,
+    pub luma_log2_weight_denom: u8,
+    pub chroma_log2_weight_denom: u8,
+    pub luma_weight_l0: [i8; 32usize],
+    pub luma_offset_l0: [i8; 32usize],
+    pub chroma_weight_l0: [[i8; 2usize]; 32usize],
+    pub chroma_offset_l0: [[i8; 2usize]; 32usize],
+    pub luma_weight_l1: [i8; 32usize],
+    pub luma_offset_l1: [i8; 32usize],
+    pub chroma_weight_l1: [[i8; 2usize]; 32usize],
+    pub chroma_offset_l1: [[i8; 2usize]; 32usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH264WeightTable() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264WeightTable> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH264WeightTable>(),
+        404usize,
+        concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH264WeightTable>(),
+        4usize,
+        concat!("Alignment of ", stringify!(StdVideoEncodeH264WeightTable))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
             stringify!(flags)
         )
     );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(luma_log2_weight_denom)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_log2_weight_denom) as usize - ptr as usize },
+        17usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(chroma_log2_weight_denom)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0) as usize - ptr as usize },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(luma_weight_l0)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize },
+        50usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(luma_offset_l0)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0) as usize - ptr as usize },
+        82usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(chroma_weight_l0)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_offset_l0) as usize - ptr as usize },
+        146usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(chroma_offset_l0)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1) as usize - ptr as usize },
+        210usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(luma_weight_l1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize },
+        242usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(luma_offset_l1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1) as usize - ptr as usize },
+        274usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(chroma_weight_l1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_offset_l1) as usize - ptr as usize },
+        338usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264WeightTable),
+            "::",
+            stringify!(chroma_offset_l1)
+        )
+    );
 }
 #[repr(C)]
 #[repr(align(4))]
@@ -6611,122 +6823,90 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeaderFlags() {
 }
 impl StdVideoEncodeH264SliceHeaderFlags {
     #[inline]
-    pub fn idr_flag(&self) -> u32 {
+    pub fn direct_spatial_mv_pred_flag(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_idr_flag(&mut self, val: u32) {
+    pub fn set_direct_spatial_mv_pred_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(0usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn is_reference_flag(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_is_reference_flag(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(1usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
     pub fn num_ref_idx_active_override_flag(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
     }
     #[inline]
     pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(2usize, 1u8, val as u64)
+            self._bitfield_1.set(1usize, 1u8, val as u64)
         }
     }
     #[inline]
     pub fn no_output_of_prior_pics_flag(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
     }
     #[inline]
     pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(3usize, 1u8, val as u64)
-        }
-    }
-    #[inline]
-    pub fn long_term_reference_flag(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
-    }
-    #[inline]
-    pub fn set_long_term_reference_flag(&mut self, val: u32) {
-        unsafe {
-            let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(4usize, 1u8, val as u64)
+            self._bitfield_1.set(2usize, 1u8, val as u64)
         }
     }
     #[inline]
     pub fn adaptive_ref_pic_marking_mode_flag(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
     }
     #[inline]
     pub fn set_adaptive_ref_pic_marking_mode_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(5usize, 1u8, val as u64)
+            self._bitfield_1.set(3usize, 1u8, val as u64)
         }
     }
     #[inline]
     pub fn no_prior_references_available_flag(&self) -> u32 {
-        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
     }
     #[inline]
     pub fn set_no_prior_references_available_flag(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
-            self._bitfield_1.set(6usize, 1u8, val as u64)
+            self._bitfield_1.set(4usize, 1u8, val as u64)
         }
     }
     #[inline]
     pub fn new_bitfield_1(
-        idr_flag: u32,
-        is_reference_flag: u32,
+        direct_spatial_mv_pred_flag: u32,
         num_ref_idx_active_override_flag: u32,
         no_output_of_prior_pics_flag: u32,
-        long_term_reference_flag: u32,
         adaptive_ref_pic_marking_mode_flag: u32,
         no_prior_references_available_flag: u32,
     ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
         let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
         __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let idr_flag: u32 = unsafe { ::std::mem::transmute(idr_flag) };
-            idr_flag as u64
+            let direct_spatial_mv_pred_flag: u32 =
+                unsafe { ::std::mem::transmute(direct_spatial_mv_pred_flag) };
+            direct_spatial_mv_pred_flag as u64
         });
         __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) };
-            is_reference_flag as u64
-        });
-        __bindgen_bitfield_unit.set(2usize, 1u8, {
             let num_ref_idx_active_override_flag: u32 =
                 unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) };
             num_ref_idx_active_override_flag as u64
         });
-        __bindgen_bitfield_unit.set(3usize, 1u8, {
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
             let no_output_of_prior_pics_flag: u32 =
                 unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) };
             no_output_of_prior_pics_flag as u64
         });
-        __bindgen_bitfield_unit.set(4usize, 1u8, {
-            let long_term_reference_flag: u32 =
-                unsafe { ::std::mem::transmute(long_term_reference_flag) };
-            long_term_reference_flag as u64
-        });
-        __bindgen_bitfield_unit.set(5usize, 1u8, {
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
             let adaptive_ref_pic_marking_mode_flag: u32 =
                 unsafe { ::std::mem::transmute(adaptive_ref_pic_marking_mode_flag) };
             adaptive_ref_pic_marking_mode_flag as u64
         });
-        __bindgen_bitfield_unit.set(6usize, 1u8, {
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
             let no_prior_references_available_flag: u32 =
                 unsafe { ::std::mem::transmute(no_prior_references_available_flag) };
             no_prior_references_available_flag as u64
@@ -6782,11 +6962,11 @@ impl StdVideoEncodeH264PictureInfoFlags {
         }
     }
     #[inline]
-    pub fn long_term_reference_flag(&self) -> u32 {
+    pub fn used_for_long_term_reference(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_long_term_reference_flag(&mut self, val: u32) {
+    pub fn set_used_for_long_term_reference(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(2usize, 1u8, val as u64)
@@ -6796,7 +6976,7 @@ impl StdVideoEncodeH264PictureInfoFlags {
     pub fn new_bitfield_1(
         idr_flag: u32,
         is_reference_flag: u32,
-        long_term_reference_flag: u32,
+        used_for_long_term_reference: u32,
     ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
         let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
         __bindgen_bitfield_unit.set(0usize, 1u8, {
@@ -6808,9 +6988,9 @@ impl StdVideoEncodeH264PictureInfoFlags {
             is_reference_flag as u64
         });
         __bindgen_bitfield_unit.set(2usize, 1u8, {
-            let long_term_reference_flag: u32 =
-                unsafe { ::std::mem::transmute(long_term_reference_flag) };
-            long_term_reference_flag as u64
+            let used_for_long_term_reference: u32 =
+                unsafe { ::std::mem::transmute(used_for_long_term_reference) };
+            used_for_long_term_reference as u64
         });
         __bindgen_bitfield_unit
     }
@@ -6818,42 +6998,100 @@ impl StdVideoEncodeH264PictureInfoFlags {
 #[repr(C)]
 #[repr(align(4))]
 #[derive(Debug, Copy, Clone)]
-pub struct StdVideoEncodeH264RefMgmtFlags {
+pub struct StdVideoEncodeH264ReferenceInfoFlags {
     pub _bitfield_align_1: [u8; 0],
     pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
     pub __bindgen_padding_0: [u8; 3usize],
 }
 #[test]
-fn bindgen_test_layout_StdVideoEncodeH264RefMgmtFlags() {
+fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfoFlags() {
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH264ReferenceInfoFlags>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(StdVideoEncodeH264ReferenceInfoFlags)
+        )
+    );
     assert_eq!(
-        ::std::mem::size_of::<StdVideoEncodeH264RefMgmtFlags>(),
+        ::std::mem::align_of::<StdVideoEncodeH264ReferenceInfoFlags>(),
         4usize,
-        concat!("Size of: ", stringify!(StdVideoEncodeH264RefMgmtFlags))
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH264ReferenceInfoFlags)
+        )
+    );
+}
+impl StdVideoEncodeH264ReferenceInfoFlags {
+    #[inline]
+    pub fn used_for_long_term_reference(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_used_for_long_term_reference(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        used_for_long_term_reference: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let used_for_long_term_reference: u32 =
+                unsafe { ::std::mem::transmute(used_for_long_term_reference) };
+            used_for_long_term_reference as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH264ReferenceListsInfoFlags {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfoFlags() {
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH264ReferenceListsInfoFlags>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(StdVideoEncodeH264ReferenceListsInfoFlags)
+        )
     );
     assert_eq!(
-        ::std::mem::align_of::<StdVideoEncodeH264RefMgmtFlags>(),
+        ::std::mem::align_of::<StdVideoEncodeH264ReferenceListsInfoFlags>(),
         4usize,
-        concat!("Alignment of ", stringify!(StdVideoEncodeH264RefMgmtFlags))
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH264ReferenceListsInfoFlags)
+        )
     );
 }
-impl StdVideoEncodeH264RefMgmtFlags {
+impl StdVideoEncodeH264ReferenceListsInfoFlags {
     #[inline]
-    pub fn ref_pic_list_modification_l0_flag(&self) -> u32 {
+    pub fn ref_pic_list_modification_flag_l0(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_ref_pic_list_modification_l0_flag(&mut self, val: u32) {
+    pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(0usize, 1u8, val as u64)
         }
     }
     #[inline]
-    pub fn ref_pic_list_modification_l1_flag(&self) -> u32 {
+    pub fn ref_pic_list_modification_flag_l1(&self) -> u32 {
         unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
     }
     #[inline]
-    pub fn set_ref_pic_list_modification_l1_flag(&mut self, val: u32) {
+    pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) {
         unsafe {
             let val: u32 = ::std::mem::transmute(val);
             self._bitfield_1.set(1usize, 1u8, val as u64)
@@ -6861,19 +7099,19 @@ impl StdVideoEncodeH264RefMgmtFlags {
     }
     #[inline]
     pub fn new_bitfield_1(
-        ref_pic_list_modification_l0_flag: u32,
-        ref_pic_list_modification_l1_flag: u32,
+        ref_pic_list_modification_flag_l0: u32,
+        ref_pic_list_modification_flag_l1: u32,
     ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
         let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
         __bindgen_bitfield_unit.set(0usize, 1u8, {
-            let ref_pic_list_modification_l0_flag: u32 =
-                unsafe { ::std::mem::transmute(ref_pic_list_modification_l0_flag) };
-            ref_pic_list_modification_l0_flag as u64
+            let ref_pic_list_modification_flag_l0: u32 =
+                unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) };
+            ref_pic_list_modification_flag_l0 as u64
         });
         __bindgen_bitfield_unit.set(1usize, 1u8, {
-            let ref_pic_list_modification_l1_flag: u32 =
-                unsafe { ::std::mem::transmute(ref_pic_list_modification_l1_flag) };
-            ref_pic_list_modification_l1_flag as u64
+            let ref_pic_list_modification_flag_l1: u32 =
+                unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) };
+            ref_pic_list_modification_flag_l1 as u64
         });
         __bindgen_bitfield_unit
     }
@@ -6887,6 +7125,9 @@ pub struct StdVideoEncodeH264RefListModEntry {
 }
 #[test]
 fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264RefListModEntry> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoEncodeH264RefListModEntry>(),
         8usize,
@@ -6902,8 +7143,7 @@ fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefListModEntry>()))
-                .modification_of_pic_nums_idc as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).modification_of_pic_nums_idc) as usize - ptr as usize
         },
         0usize,
         concat!(
@@ -6914,10 +7154,7 @@ fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefListModEntry>())).abs_diff_pic_num_minus1
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).abs_diff_pic_num_minus1) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -6927,10 +7164,7 @@ fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefListModEntry>())).long_term_pic_num
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
@@ -6951,6 +7185,9 @@ pub struct StdVideoEncodeH264RefPicMarkingEntry {
 }
 #[test]
 fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264RefPicMarkingEntry> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoEncodeH264RefPicMarkingEntry>(),
         12usize,
@@ -6968,10 +7205,7 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefPicMarkingEntry>())).operation as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6982,8 +7216,7 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefPicMarkingEntry>()))
-                .difference_of_pic_nums_minus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).difference_of_pic_nums_minus1) as usize - ptr as usize
         },
         4usize,
         concat!(
@@ -6994,10 +7227,7 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefPicMarkingEntry>())).long_term_pic_num
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
@@ -7007,10 +7237,7 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefPicMarkingEntry>())).long_term_frame_idx
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -7021,8 +7248,7 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefPicMarkingEntry>()))
-                .max_long_term_frame_idx_plus1 as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).max_long_term_frame_idx_plus1) as usize - ptr as usize
         },
         10usize,
         concat!(
@@ -7035,120 +7261,157 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
 }
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
-pub struct StdVideoEncodeH264RefMemMgmtCtrlOperations {
-    pub flags: StdVideoEncodeH264RefMgmtFlags,
+pub struct StdVideoEncodeH264ReferenceListsInfo {
+    pub flags: StdVideoEncodeH264ReferenceListsInfoFlags,
+    pub refPicList0EntryCount: u8,
+    pub refPicList1EntryCount: u8,
     pub refList0ModOpCount: u8,
-    pub pRefList0ModOperations: *mut StdVideoEncodeH264RefListModEntry,
     pub refList1ModOpCount: u8,
-    pub pRefList1ModOperations: *mut StdVideoEncodeH264RefListModEntry,
     pub refPicMarkingOpCount: u8,
-    pub pRefPicMarkingOperations: *mut StdVideoEncodeH264RefPicMarkingEntry,
+    pub reserved1: [u8; 7usize],
+    pub pRefPicList0Entries: *const u8,
+    pub pRefPicList1Entries: *const u8,
+    pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry,
+    pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry,
+    pub pRefPicMarkingOperations: *const StdVideoEncodeH264RefPicMarkingEntry,
 }
 #[test]
-fn bindgen_test_layout_StdVideoEncodeH264RefMemMgmtCtrlOperations() {
+fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264ReferenceListsInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
-        ::std::mem::size_of::<StdVideoEncodeH264RefMemMgmtCtrlOperations>(),
-        48usize,
+        ::std::mem::size_of::<StdVideoEncodeH264ReferenceListsInfo>(),
+        56usize,
         concat!(
             "Size of: ",
-            stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations)
+            stringify!(StdVideoEncodeH264ReferenceListsInfo)
         )
     );
     assert_eq!(
-        ::std::mem::align_of::<StdVideoEncodeH264RefMemMgmtCtrlOperations>(),
+        ::std::mem::align_of::<StdVideoEncodeH264ReferenceListsInfo>(),
         8usize,
         concat!(
             "Alignment of ",
-            stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations)
+            stringify!(StdVideoEncodeH264ReferenceListsInfo)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefMemMgmtCtrlOperations>())).flags as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations),
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
             "::",
             stringify!(flags)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefMemMgmtCtrlOperations>()))
-                .refList0ModOpCount as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).refPicList0EntryCount) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations),
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
+            "::",
+            stringify!(refPicList0EntryCount)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).refPicList1EntryCount) as usize - ptr as usize },
+        5usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
+            "::",
+            stringify!(refPicList1EntryCount)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
             "::",
             stringify!(refList0ModOpCount)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefMemMgmtCtrlOperations>()))
-                .pRefList0ModOperations as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize },
+        7usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
+            "::",
+            stringify!(refList1ModOpCount)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations),
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
             "::",
-            stringify!(pRefList0ModOperations)
+            stringify!(refPicMarkingOpCount)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefMemMgmtCtrlOperations>()))
-                .refList1ModOpCount as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        9usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
+            "::",
+            stringify!(reserved1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList0Entries) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations),
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
             "::",
-            stringify!(refList1ModOpCount)
+            stringify!(pRefPicList0Entries)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefMemMgmtCtrlOperations>()))
-                .pRefList1ModOperations as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList1Entries) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations),
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
             "::",
-            stringify!(pRefList1ModOperations)
+            stringify!(pRefPicList1Entries)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefMemMgmtCtrlOperations>()))
-                .refPicMarkingOpCount as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pRefList0ModOperations) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations),
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
             "::",
-            stringify!(refPicMarkingOpCount)
+            stringify!(pRefList0ModOperations)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264RefMemMgmtCtrlOperations>()))
-                .pRefPicMarkingOperations as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pRefList1ModOperations) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264RefMemMgmtCtrlOperations),
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
+            "::",
+            stringify!(pRefList1ModOperations)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pRefPicMarkingOperations) as usize - ptr as usize },
+        48usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceListsInfo),
             "::",
             stringify!(pRefPicMarkingOperations)
         )
@@ -7158,14 +7421,18 @@ fn bindgen_test_layout_StdVideoEncodeH264RefMemMgmtCtrlOperations() {
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoEncodeH264PictureInfo {
     pub flags: StdVideoEncodeH264PictureInfoFlags,
+    pub seq_parameter_set_id: u8,
+    pub pic_parameter_set_id: u8,
+    pub reserved1: u16,
     pub pictureType: StdVideoH264PictureType,
-    pub frameNum: u32,
-    pub pictureOrderCount: u32,
-    pub long_term_pic_num: u16,
-    pub long_term_frame_idx: u16,
+    pub frame_num: u32,
+    pub PicOrderCnt: i32,
 }
 #[test]
 fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264PictureInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoEncodeH264PictureInfo>(),
         20usize,
@@ -7177,9 +7444,7 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() {
         concat!("Alignment of ", stringify!(StdVideoEncodeH264PictureInfo))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264PictureInfo>())).flags as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -7189,65 +7454,147 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264PictureInfo>())).pictureType as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoEncodeH264PictureInfo),
             "::",
-            stringify!(pictureType)
+            stringify!(seq_parameter_set_id)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264PictureInfo>())).frameNum as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
+        5usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264PictureInfo),
+            "::",
+            stringify!(pic_parameter_set_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264PictureInfo),
+            "::",
+            stringify!(reserved1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoEncodeH264PictureInfo),
             "::",
-            stringify!(frameNum)
+            stringify!(pictureType)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264PictureInfo>())).pictureOrderCount as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoEncodeH264PictureInfo),
             "::",
-            stringify!(pictureOrderCount)
+            stringify!(frame_num)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264PictureInfo>())).long_term_pic_num as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoEncodeH264PictureInfo),
             "::",
+            stringify!(PicOrderCnt)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH264ReferenceInfo {
+    pub flags: StdVideoEncodeH264ReferenceInfoFlags,
+    pub pictureType: StdVideoH264PictureType,
+    pub FrameNum: u32,
+    pub PicOrderCnt: i32,
+    pub long_term_pic_num: u16,
+    pub long_term_frame_idx: u16,
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264ReferenceInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH264ReferenceInfo>(),
+        20usize,
+        concat!("Size of: ", stringify!(StdVideoEncodeH264ReferenceInfo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH264ReferenceInfo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(StdVideoEncodeH264ReferenceInfo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceInfo),
+            "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceInfo),
+            "::",
+            stringify!(pictureType)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceInfo),
+            "::",
+            stringify!(FrameNum)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceInfo),
+            "::",
+            stringify!(PicOrderCnt)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264ReferenceInfo),
+            "::",
             stringify!(long_term_pic_num)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264PictureInfo>())).long_term_frame_idx
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize },
         18usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264PictureInfo),
+            stringify!(StdVideoEncodeH264ReferenceInfo),
             "::",
             stringify!(long_term_frame_idx)
         )
@@ -7257,9 +7604,8 @@ fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() {
 #[derive(Debug, Copy, Clone)]
 pub struct StdVideoEncodeH264SliceHeader {
     pub flags: StdVideoEncodeH264SliceHeaderFlags,
+    pub first_mb_in_slice: u32,
     pub slice_type: StdVideoH264SliceType,
-    pub seq_parameter_set_id: u8,
-    pub pic_parameter_set_id: u8,
     pub idr_pic_id: u16,
     pub num_ref_idx_l0_active_minus1: u8,
     pub num_ref_idx_l1_active_minus1: u8,
@@ -7267,10 +7613,15 @@ pub struct StdVideoEncodeH264SliceHeader {
     pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc,
     pub slice_alpha_c0_offset_div2: i8,
     pub slice_beta_offset_div2: i8,
-    pub pMemMgmtCtrlOperations: *mut StdVideoEncodeH264RefMemMgmtCtrlOperations,
+    pub reserved1: u16,
+    pub reserved2: u32,
+    pub pWeightTable: *const StdVideoEncodeH264WeightTable,
 }
 #[test]
 fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264SliceHeader> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::std::mem::size_of::<StdVideoEncodeH264SliceHeader>(),
         40usize,
@@ -7282,9 +7633,7 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() {
         concat!("Alignment of ", stringify!(StdVideoEncodeH264SliceHeader))
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).flags as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -7294,146 +7643,1501 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).slice_type as *const _
-                as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).first_mb_in_slice) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoEncodeH264SliceHeader),
             "::",
-            stringify!(slice_type)
+            stringify!(first_mb_in_slice)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).seq_parameter_set_id
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoEncodeH264SliceHeader),
             "::",
-            stringify!(seq_parameter_set_id)
+            stringify!(slice_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264SliceHeader),
+            "::",
+            stringify!(idr_pic_id)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).pic_parameter_set_id
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
         },
-        9usize,
+        14usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoEncodeH264SliceHeader),
             "::",
-            stringify!(pic_parameter_set_id)
+            stringify!(num_ref_idx_l0_active_minus1)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).idr_pic_id as *const _
-                as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
         },
-        10usize,
+        15usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoEncodeH264SliceHeader),
             "::",
-            stringify!(idr_pic_id)
+            stringify!(num_ref_idx_l1_active_minus1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).cabac_init_idc) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264SliceHeader),
+            "::",
+            stringify!(cabac_init_idc)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).num_ref_idx_l0_active_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).disable_deblocking_filter_idc) as usize - ptr as usize
         },
-        12usize,
+        20usize,
         concat!(
             "Offset of field: ",
             stringify!(StdVideoEncodeH264SliceHeader),
             "::",
-            stringify!(num_ref_idx_l0_active_minus1)
+            stringify!(disable_deblocking_filter_idc)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_alpha_c0_offset_div2) as usize - ptr as usize },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264SliceHeader),
+            "::",
+            stringify!(slice_alpha_c0_offset_div2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize },
+        25usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264SliceHeader),
+            "::",
+            stringify!(slice_beta_offset_div2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        26usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264SliceHeader),
+            "::",
+            stringify!(reserved1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
+        28usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264SliceHeader),
+            "::",
+            stringify!(reserved2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH264SliceHeader),
+            "::",
+            stringify!(pWeightTable)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265WeightTableFlags {
+    pub luma_weight_l0_flag: u16,
+    pub chroma_weight_l0_flag: u16,
+    pub luma_weight_l1_flag: u16,
+    pub chroma_weight_l1_flag: u16,
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265WeightTableFlags() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265WeightTableFlags> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265WeightTableFlags>(),
+        8usize,
+        concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTableFlags))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265WeightTableFlags>(),
+        2usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH265WeightTableFlags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTableFlags),
+            "::",
+            stringify!(luma_weight_l0_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTableFlags),
+            "::",
+            stringify!(chroma_weight_l0_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTableFlags),
+            "::",
+            stringify!(luma_weight_l1_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTableFlags),
+            "::",
+            stringify!(chroma_weight_l1_flag)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265WeightTable {
+    pub flags: StdVideoEncodeH265WeightTableFlags,
+    pub luma_log2_weight_denom: u8,
+    pub delta_chroma_log2_weight_denom: i8,
+    pub delta_luma_weight_l0: [i8; 15usize],
+    pub luma_offset_l0: [i8; 15usize],
+    pub delta_chroma_weight_l0: [[i8; 2usize]; 15usize],
+    pub delta_chroma_offset_l0: [[i8; 2usize]; 15usize],
+    pub delta_luma_weight_l1: [i8; 15usize],
+    pub luma_offset_l1: [i8; 15usize],
+    pub delta_chroma_weight_l1: [[i8; 2usize]; 15usize],
+    pub delta_chroma_offset_l1: [[i8; 2usize]; 15usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265WeightTable() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265WeightTable> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265WeightTable>(),
+        190usize,
+        concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTable))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265WeightTable>(),
+        2usize,
+        concat!("Alignment of ", stringify!(StdVideoEncodeH265WeightTable))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(luma_log2_weight_denom)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).num_ref_idx_l1_active_minus1
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).delta_chroma_log2_weight_denom) as usize - ptr as usize
         },
+        9usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(delta_chroma_log2_weight_denom)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_luma_weight_l0) as usize - ptr as usize },
+        10usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(delta_luma_weight_l0)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize },
+        25usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(luma_offset_l0)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_weight_l0) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(delta_chroma_weight_l0)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_offset_l0) as usize - ptr as usize },
+        70usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(delta_chroma_offset_l0)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_luma_weight_l1) as usize - ptr as usize },
+        100usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(delta_luma_weight_l1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize },
+        115usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(luma_offset_l1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_weight_l1) as usize - ptr as usize },
+        130usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(delta_chroma_weight_l1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_offset_l1) as usize - ptr as usize },
+        160usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265WeightTable),
+            "::",
+            stringify!(delta_chroma_offset_l1)
+        )
+    );
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265SliceSegmentHeaderFlags {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
+    pub __bindgen_padding_0: u16,
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeaderFlags() {
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265SliceSegmentHeaderFlags>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265SliceSegmentHeaderFlags>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags)
+        )
+    );
+}
+impl StdVideoEncodeH265SliceSegmentHeaderFlags {
+    #[inline]
+    pub fn first_slice_segment_in_pic_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_first_slice_segment_in_pic_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn no_output_of_prior_pics_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn dependent_slice_segment_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_dependent_slice_segment_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn pic_output_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_pic_output_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn slice_temporal_mvp_enable_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_slice_temporal_mvp_enable_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(5usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn slice_sao_luma_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_slice_sao_luma_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(6usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn slice_sao_chroma_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_slice_sao_chroma_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(7usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn num_ref_idx_active_override_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(8usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn mvd_l1_zero_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_mvd_l1_zero_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(9usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn cabac_init_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_cabac_init_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(10usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn cu_chroma_qp_offset_enabled_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_cu_chroma_qp_offset_enabled_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(11usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn deblocking_filter_override_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_deblocking_filter_override_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(12usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn slice_deblocking_filter_disabled_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_slice_deblocking_filter_disabled_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(13usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn collocated_from_l0_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_collocated_from_l0_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(14usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(15usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        first_slice_segment_in_pic_flag: u32,
+        no_output_of_prior_pics_flag: u32,
+        dependent_slice_segment_flag: u32,
+        pic_output_flag: u32,
+        short_term_ref_pic_set_sps_flag: u32,
+        slice_temporal_mvp_enable_flag: u32,
+        slice_sao_luma_flag: u32,
+        slice_sao_chroma_flag: u32,
+        num_ref_idx_active_override_flag: u32,
+        mvd_l1_zero_flag: u32,
+        cabac_init_flag: u32,
+        cu_chroma_qp_offset_enabled_flag: u32,
+        deblocking_filter_override_flag: u32,
+        slice_deblocking_filter_disabled_flag: u32,
+        collocated_from_l0_flag: u32,
+        slice_loop_filter_across_slices_enabled_flag: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let first_slice_segment_in_pic_flag: u32 =
+                unsafe { ::std::mem::transmute(first_slice_segment_in_pic_flag) };
+            first_slice_segment_in_pic_flag as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let no_output_of_prior_pics_flag: u32 =
+                unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) };
+            no_output_of_prior_pics_flag as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let dependent_slice_segment_flag: u32 =
+                unsafe { ::std::mem::transmute(dependent_slice_segment_flag) };
+            dependent_slice_segment_flag as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let pic_output_flag: u32 = unsafe { ::std::mem::transmute(pic_output_flag) };
+            pic_output_flag as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
+            let short_term_ref_pic_set_sps_flag: u32 =
+                unsafe { ::std::mem::transmute(short_term_ref_pic_set_sps_flag) };
+            short_term_ref_pic_set_sps_flag as u64
+        });
+        __bindgen_bitfield_unit.set(5usize, 1u8, {
+            let slice_temporal_mvp_enable_flag: u32 =
+                unsafe { ::std::mem::transmute(slice_temporal_mvp_enable_flag) };
+            slice_temporal_mvp_enable_flag as u64
+        });
+        __bindgen_bitfield_unit.set(6usize, 1u8, {
+            let slice_sao_luma_flag: u32 = unsafe { ::std::mem::transmute(slice_sao_luma_flag) };
+            slice_sao_luma_flag as u64
+        });
+        __bindgen_bitfield_unit.set(7usize, 1u8, {
+            let slice_sao_chroma_flag: u32 =
+                unsafe { ::std::mem::transmute(slice_sao_chroma_flag) };
+            slice_sao_chroma_flag as u64
+        });
+        __bindgen_bitfield_unit.set(8usize, 1u8, {
+            let num_ref_idx_active_override_flag: u32 =
+                unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) };
+            num_ref_idx_active_override_flag as u64
+        });
+        __bindgen_bitfield_unit.set(9usize, 1u8, {
+            let mvd_l1_zero_flag: u32 = unsafe { ::std::mem::transmute(mvd_l1_zero_flag) };
+            mvd_l1_zero_flag as u64
+        });
+        __bindgen_bitfield_unit.set(10usize, 1u8, {
+            let cabac_init_flag: u32 = unsafe { ::std::mem::transmute(cabac_init_flag) };
+            cabac_init_flag as u64
+        });
+        __bindgen_bitfield_unit.set(11usize, 1u8, {
+            let cu_chroma_qp_offset_enabled_flag: u32 =
+                unsafe { ::std::mem::transmute(cu_chroma_qp_offset_enabled_flag) };
+            cu_chroma_qp_offset_enabled_flag as u64
+        });
+        __bindgen_bitfield_unit.set(12usize, 1u8, {
+            let deblocking_filter_override_flag: u32 =
+                unsafe { ::std::mem::transmute(deblocking_filter_override_flag) };
+            deblocking_filter_override_flag as u64
+        });
+        __bindgen_bitfield_unit.set(13usize, 1u8, {
+            let slice_deblocking_filter_disabled_flag: u32 =
+                unsafe { ::std::mem::transmute(slice_deblocking_filter_disabled_flag) };
+            slice_deblocking_filter_disabled_flag as u64
+        });
+        __bindgen_bitfield_unit.set(14usize, 1u8, {
+            let collocated_from_l0_flag: u32 =
+                unsafe { ::std::mem::transmute(collocated_from_l0_flag) };
+            collocated_from_l0_flag as u64
+        });
+        __bindgen_bitfield_unit.set(15usize, 1u8, {
+            let slice_loop_filter_across_slices_enabled_flag: u32 =
+                unsafe { ::std::mem::transmute(slice_loop_filter_across_slices_enabled_flag) };
+            slice_loop_filter_across_slices_enabled_flag as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265SliceSegmentLongTermRefPics {
+    pub num_long_term_sps: u8,
+    pub num_long_term_pics: u8,
+    pub lt_idx_sps: [u8; 32usize],
+    pub poc_lsb_lt: [u8; 16usize],
+    pub used_by_curr_pic_lt_flag: u16,
+    pub delta_poc_msb_present_flag: [u8; 48usize],
+    pub delta_poc_msb_cycle_lt: [u8; 48usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265SliceSegmentLongTermRefPics> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265SliceSegmentLongTermRefPics>(),
+        148usize,
+        concat!(
+            "Size of: ",
+            stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265SliceSegmentLongTermRefPics>(),
+        2usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
+            "::",
+            stringify!(num_long_term_sps)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize },
+        1usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
+            "::",
+            stringify!(num_long_term_pics)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).lt_idx_sps) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
+            "::",
+            stringify!(lt_idx_sps)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).poc_lsb_lt) as usize - ptr as usize },
+        34usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
+            "::",
+            stringify!(poc_lsb_lt)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_flag) as usize - ptr as usize },
+        50usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
+            "::",
+            stringify!(used_by_curr_pic_lt_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_present_flag) as usize - ptr as usize },
+        52usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
+            "::",
+            stringify!(delta_poc_msb_present_flag)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_cycle_lt) as usize - ptr as usize },
+        100usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
+            "::",
+            stringify!(delta_poc_msb_cycle_lt)
+        )
+    );
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265SliceSegmentHeader {
+    pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags,
+    pub slice_type: StdVideoH265SliceType,
+    pub slice_segment_address: u32,
+    pub short_term_ref_pic_set_idx: u8,
+    pub collocated_ref_idx: u8,
+    pub num_ref_idx_l0_active_minus1: u8,
+    pub num_ref_idx_l1_active_minus1: u8,
+    pub MaxNumMergeCand: u8,
+    pub slice_cb_qp_offset: i8,
+    pub slice_cr_qp_offset: i8,
+    pub slice_beta_offset_div2: i8,
+    pub slice_tc_offset_div2: i8,
+    pub slice_act_y_qp_offset: i8,
+    pub slice_act_cb_qp_offset: i8,
+    pub slice_act_cr_qp_offset: i8,
+    pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet,
+    pub pLongTermRefPics: *const StdVideoEncodeH265SliceSegmentLongTermRefPics,
+    pub pWeightTable: *const StdVideoEncodeH265WeightTable,
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265SliceSegmentHeader> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265SliceSegmentHeader>(),
+        48usize,
+        concat!(
+            "Size of: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265SliceSegmentHeader>(),
+        8usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(slice_type)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_segment_address) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(slice_segment_address)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).short_term_ref_pic_set_idx) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(short_term_ref_pic_set_idx)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).collocated_ref_idx) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264SliceHeader),
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
             "::",
-            stringify!(num_ref_idx_l1_active_minus1)
+            stringify!(collocated_ref_idx)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).cabac_init_idc as *const _
-                as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
         },
-        16usize,
+        14usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264SliceHeader),
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
             "::",
-            stringify!(cabac_init_idc)
+            stringify!(num_ref_idx_l0_active_minus1)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).disable_deblocking_filter_idc
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
         },
+        15usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(num_ref_idx_l1_active_minus1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).MaxNumMergeCand) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(MaxNumMergeCand)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_cb_qp_offset) as usize - ptr as usize },
+        17usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(slice_cb_qp_offset)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_cr_qp_offset) as usize - ptr as usize },
+        18usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(slice_cr_qp_offset)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize },
+        19usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(slice_beta_offset_div2)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_tc_offset_div2) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264SliceHeader),
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
             "::",
-            stringify!(disable_deblocking_filter_idc)
+            stringify!(slice_tc_offset_div2)
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).slice_alpha_c0_offset_div2
-                as *const _ as usize
-        },
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_act_y_qp_offset) as usize - ptr as usize },
+        21usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(slice_act_y_qp_offset)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cb_qp_offset) as usize - ptr as usize },
+        22usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(slice_act_cb_qp_offset)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cr_qp_offset) as usize - ptr as usize },
+        23usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(slice_act_cr_qp_offset)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264SliceHeader),
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
             "::",
-            stringify!(slice_alpha_c0_offset_div2)
+            stringify!(pShortTermRefPicSet)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPics) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(pLongTermRefPics)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265SliceSegmentHeader),
+            "::",
+            stringify!(pWeightTable)
+        )
+    );
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265ReferenceListsInfoFlags {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfoFlags() {
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265ReferenceListsInfoFlags>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfoFlags)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265ReferenceListsInfoFlags>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfoFlags)
+        )
+    );
+}
+impl StdVideoEncodeH265ReferenceListsInfoFlags {
+    #[inline]
+    pub fn ref_pic_list_modification_flag_l0(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn ref_pic_list_modification_flag_l1(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        ref_pic_list_modification_flag_l0: u32,
+        ref_pic_list_modification_flag_l1: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let ref_pic_list_modification_flag_l0: u32 =
+                unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) };
+            ref_pic_list_modification_flag_l0 as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let ref_pic_list_modification_flag_l1: u32 =
+                unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) };
+            ref_pic_list_modification_flag_l1 as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265ReferenceListsInfo {
+    pub flags: StdVideoEncodeH265ReferenceListsInfoFlags,
+    pub num_ref_idx_l0_active_minus1: u8,
+    pub num_ref_idx_l1_active_minus1: u8,
+    pub reserved1: u16,
+    pub pRefPicList0Entries: *const u8,
+    pub pRefPicList1Entries: *const u8,
+    pub pRefList0Modifications: *const u8,
+    pub pRefList1Modifications: *const u8,
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265ReferenceListsInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265ReferenceListsInfo>(),
+        40usize,
+        concat!(
+            "Size of: ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfo)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265ReferenceListsInfo>(),
+        8usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfo)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfo),
+            "::",
+            stringify!(flags)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).slice_beta_offset_div2
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
         },
-        25usize,
+        4usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264SliceHeader),
+            stringify!(StdVideoEncodeH265ReferenceListsInfo),
             "::",
-            stringify!(slice_beta_offset_div2)
+            stringify!(num_ref_idx_l0_active_minus1)
         )
     );
     assert_eq!(
         unsafe {
-            &(*(::std::ptr::null::<StdVideoEncodeH264SliceHeader>())).pMemMgmtCtrlOperations
-                as *const _ as usize
+            ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
         },
+        5usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfo),
+            "::",
+            stringify!(num_ref_idx_l1_active_minus1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfo),
+            "::",
+            stringify!(reserved1)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList0Entries) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfo),
+            "::",
+            stringify!(pRefPicList0Entries)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList1Entries) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfo),
+            "::",
+            stringify!(pRefPicList1Entries)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pRefList0Modifications) as usize - ptr as usize },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceListsInfo),
+            "::",
+            stringify!(pRefList0Modifications)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pRefList1Modifications) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
-            stringify!(StdVideoEncodeH264SliceHeader),
+            stringify!(StdVideoEncodeH265ReferenceListsInfo),
+            "::",
+            stringify!(pRefList1Modifications)
+        )
+    );
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265PictureInfoFlags {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265PictureInfoFlags() {
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265PictureInfoFlags>(),
+        4usize,
+        concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfoFlags))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265PictureInfoFlags>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH265PictureInfoFlags)
+        )
+    );
+}
+impl StdVideoEncodeH265PictureInfoFlags {
+    #[inline]
+    pub fn is_reference_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_is_reference_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn IrapPicFlag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_IrapPicFlag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn long_term_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_long_term_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(2usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn discardable_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_discardable_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(3usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn cross_layer_bla_flag(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_cross_layer_bla_flag(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(4usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        is_reference_flag: u32,
+        IrapPicFlag: u32,
+        long_term_flag: u32,
+        discardable_flag: u32,
+        cross_layer_bla_flag: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) };
+            is_reference_flag as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let IrapPicFlag: u32 = unsafe { ::std::mem::transmute(IrapPicFlag) };
+            IrapPicFlag as u64
+        });
+        __bindgen_bitfield_unit.set(2usize, 1u8, {
+            let long_term_flag: u32 = unsafe { ::std::mem::transmute(long_term_flag) };
+            long_term_flag as u64
+        });
+        __bindgen_bitfield_unit.set(3usize, 1u8, {
+            let discardable_flag: u32 = unsafe { ::std::mem::transmute(discardable_flag) };
+            discardable_flag as u64
+        });
+        __bindgen_bitfield_unit.set(4usize, 1u8, {
+            let cross_layer_bla_flag: u32 = unsafe { ::std::mem::transmute(cross_layer_bla_flag) };
+            cross_layer_bla_flag as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265PictureInfo {
+    pub flags: StdVideoEncodeH265PictureInfoFlags,
+    pub PictureType: StdVideoH265PictureType,
+    pub sps_video_parameter_set_id: u8,
+    pub pps_seq_parameter_set_id: u8,
+    pub pps_pic_parameter_set_id: u8,
+    pub TemporalId: u8,
+    pub PicOrderCntVal: i32,
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265PictureInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265PictureInfo>(),
+        16usize,
+        concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265PictureInfo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(StdVideoEncodeH265PictureInfo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265PictureInfo),
+            "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).PictureType) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265PictureInfo),
+            "::",
+            stringify!(PictureType)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265PictureInfo),
+            "::",
+            stringify!(sps_video_parameter_set_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
+        9usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265PictureInfo),
+            "::",
+            stringify!(pps_seq_parameter_set_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
+        10usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265PictureInfo),
+            "::",
+            stringify!(pps_pic_parameter_set_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize },
+        11usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265PictureInfo),
+            "::",
+            stringify!(TemporalId)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265PictureInfo),
+            "::",
+            stringify!(PicOrderCntVal)
+        )
+    );
+}
+#[repr(C)]
+#[repr(align(4))]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265ReferenceInfoFlags {
+    pub _bitfield_align_1: [u8; 0],
+    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
+    pub __bindgen_padding_0: [u8; 3usize],
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfoFlags() {
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265ReferenceInfoFlags>(),
+        4usize,
+        concat!(
+            "Size of: ",
+            stringify!(StdVideoEncodeH265ReferenceInfoFlags)
+        )
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265ReferenceInfoFlags>(),
+        4usize,
+        concat!(
+            "Alignment of ",
+            stringify!(StdVideoEncodeH265ReferenceInfoFlags)
+        )
+    );
+}
+impl StdVideoEncodeH265ReferenceInfoFlags {
+    #[inline]
+    pub fn used_for_long_term_reference(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_used_for_long_term_reference(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(0usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn unused_for_reference(&self) -> u32 {
+        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
+    }
+    #[inline]
+    pub fn set_unused_for_reference(&mut self, val: u32) {
+        unsafe {
+            let val: u32 = ::std::mem::transmute(val);
+            self._bitfield_1.set(1usize, 1u8, val as u64)
+        }
+    }
+    #[inline]
+    pub fn new_bitfield_1(
+        used_for_long_term_reference: u32,
+        unused_for_reference: u32,
+    ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
+        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
+        __bindgen_bitfield_unit.set(0usize, 1u8, {
+            let used_for_long_term_reference: u32 =
+                unsafe { ::std::mem::transmute(used_for_long_term_reference) };
+            used_for_long_term_reference as u64
+        });
+        __bindgen_bitfield_unit.set(1usize, 1u8, {
+            let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) };
+            unused_for_reference as u64
+        });
+        __bindgen_bitfield_unit
+    }
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct StdVideoEncodeH265ReferenceInfo {
+    pub flags: StdVideoEncodeH265ReferenceInfoFlags,
+    pub PictureType: StdVideoH265PictureType,
+    pub PicOrderCntVal: i32,
+    pub TemporalId: u8,
+}
+#[test]
+fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() {
+    const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265ReferenceInfo> =
+        ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<StdVideoEncodeH265ReferenceInfo>(),
+        16usize,
+        concat!("Size of: ", stringify!(StdVideoEncodeH265ReferenceInfo))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<StdVideoEncodeH265ReferenceInfo>(),
+        4usize,
+        concat!("Alignment of ", stringify!(StdVideoEncodeH265ReferenceInfo))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceInfo),
+            "::",
+            stringify!(flags)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).PictureType) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceInfo),
+            "::",
+            stringify!(PictureType)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceInfo),
+            "::",
+            stringify!(PicOrderCntVal)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(StdVideoEncodeH265ReferenceInfo),
             "::",
-            stringify!(pMemMgmtCtrlOperations)
+            stringify!(TemporalId)
         )
     );
 }
diff --git a/src/vk/platform_types.rs b/src/vk/platform_types.rs
index da98594..4d6ffe0 100644
--- a/src/vk/platform_types.rs
+++ b/src/vk/platform_types.rs
@@ -1,33 +1,26 @@
+#![allow(non_camel_case_types)]
+
 use std::os::raw::*;
 pub type RROutput = c_ulong;
 pub type VisualID = c_uint;
 pub type Display = *const c_void;
 pub type Window = c_ulong;
-#[allow(non_camel_case_types)]
 pub type xcb_connection_t = c_void;
-#[allow(non_camel_case_types)]
 pub type xcb_window_t = u32;
-#[allow(non_camel_case_types)]
 pub type xcb_visualid_t = u32;
 pub type MirConnection = *const c_void;
 pub type MirSurface = *const c_void;
 pub type HINSTANCE = *const c_void;
 pub type HWND = *const c_void;
-#[allow(non_camel_case_types)]
 pub type wl_display = c_void;
-#[allow(non_camel_case_types)]
 pub type wl_surface = c_void;
 pub type HANDLE = *mut c_void;
 pub type HMONITOR = HANDLE;
 pub type DWORD = c_ulong;
 pub type LPCWSTR = *const u16;
-#[allow(non_camel_case_types)]
 pub type zx_handle_t = u32;
-#[allow(non_camel_case_types)]
 pub type _screen_context = c_void;
-#[allow(non_camel_case_types)]
 pub type _screen_window = c_void;
-#[allow(non_camel_case_types)]
 pub type SECURITY_ATTRIBUTES = c_void;
 // Opaque types
 pub type ANativeWindow = c_void;
@@ -39,3 +32,10 @@ pub type GgpStreamDescriptor = u32;
 pub type GgpFrameToken = u64;
 pub type IDirectFB = c_void;
 pub type IDirectFBSurface = c_void;
+pub type __IOSurface = c_void;
+pub type IOSurfaceRef = *mut __IOSurface;
+pub type MTLBuffer_id = *mut c_void;
+pub type MTLCommandQueue_id = *mut c_void;
+pub type MTLDevice_id = *mut c_void;
+pub type MTLSharedEvent_id = *mut c_void;
+pub type MTLTexture_id = *mut c_void;
diff --git a/src/vk/prelude.rs b/src/vk/prelude.rs
new file mode 100644
index 0000000..cb2f177
--- /dev/null
+++ b/src/vk/prelude.rs
@@ -0,0 +1,61 @@
+use crate::vk;
+
+/// Holds 24 bits in the least significant bits of memory,
+/// and 8 bytes in the most significant bits of that memory,
+/// occupying a single [`u32`] in total. This is commonly used in
+/// [acceleration structure instances] such as
+/// [`vk::AccelerationStructureInstanceKHR`],
+/// [`vk::AccelerationStructureSRTMotionInstanceNV`] and
+/// [`vk::AccelerationStructureMatrixMotionInstanceNV`].
+///
+/// [acceleration structure instances]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkAccelerationStructureInstanceKHR.html#_description
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
+#[repr(transparent)]
+pub struct Packed24_8(u32);
+
+impl Packed24_8 {
+    pub fn new(low_24: u32, high_8: u8) -> Self {
+        Self((low_24 & 0x00ff_ffff) | (u32::from(high_8) << 24))
+    }
+
+    /// Extracts the least-significant 24 bits (3 bytes) of this integer
+    pub fn low_24(&self) -> u32 {
+        self.0 & 0xffffff
+    }
+
+    /// Extracts the most significant 8 bits (single byte) of this integer
+    pub fn high_8(&self) -> u8 {
+        (self.0 >> 24) as u8
+    }
+}
+
+impl vk::ColorComponentFlags {
+    /// Contraction of [`R`][Self::R] | [`G`][Self::G] | [`B`][Self::B] | [`A`][Self::A]
+    pub const RGBA: Self = Self(Self::R.0 | Self::G.0 | Self::B.0 | Self::A.0);
+}
+
+impl From<vk::Extent2D> for vk::Extent3D {
+    fn from(value: vk::Extent2D) -> Self {
+        Self {
+            width: value.width,
+            height: value.height,
+            depth: 1,
+        }
+    }
+}
+
+impl From<vk::Extent2D> for vk::Rect2D {
+    fn from(extent: vk::Extent2D) -> Self {
+        Self {
+            offset: Default::default(),
+            extent,
+        }
+    }
+}
+
+/// Structures implementing this trait are layout-compatible with [`vk::BaseInStructure`] and
+/// [`vk::BaseOutStructure`]. Such structures have an `s_type` field indicating its type, which
+/// must always match the value of [`TaggedStructure::STRUCTURE_TYPE`].
+pub unsafe trait TaggedStructure {
+    const STRUCTURE_TYPE: vk::StructureType;
+}