vulkan_rust_sys/
enums.rs

1///[`VkAccelerationStructureBuildTypeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildTypeKHR.html)
2#[repr(transparent)]
3#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4#[doc(alias = "VkAccelerationStructureBuildTypeKHR")]
5pub struct AccelerationStructureBuildTypeKHR(i32);
6impl AccelerationStructureBuildTypeKHR {
7    pub const HOST: Self = Self(0i32);
8    pub const DEVICE: Self = Self(1i32);
9    pub const HOST_OR_DEVICE: Self = Self(2i32);
10    #[inline]
11    pub const fn from_raw(value: i32) -> Self {
12        Self(value)
13    }
14    #[inline]
15    pub const fn as_raw(self) -> i32 {
16        self.0
17    }
18}
19impl core::fmt::Debug for AccelerationStructureBuildTypeKHR {
20    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
21        match self.0 {
22            0i32 => f.write_str("HOST"),
23            1i32 => f.write_str("DEVICE"),
24            2i32 => f.write_str("HOST_OR_DEVICE"),
25            other => {
26                write!(f, "{}({})", stringify!(AccelerationStructureBuildTypeKHR), other)
27            }
28        }
29    }
30}
31impl core::fmt::Display for AccelerationStructureBuildTypeKHR {
32    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
33        core::fmt::Debug::fmt(self, f)
34    }
35}
36impl core::error::Error for AccelerationStructureBuildTypeKHR {}
37///[`VkAccelerationStructureCompatibilityKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCompatibilityKHR.html)
38#[repr(transparent)]
39#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
40#[doc(alias = "VkAccelerationStructureCompatibilityKHR")]
41pub struct AccelerationStructureCompatibilityKHR(i32);
42impl AccelerationStructureCompatibilityKHR {
43    pub const COMPATIBLE: Self = Self(0i32);
44    pub const INCOMPATIBLE: Self = Self(1i32);
45    #[inline]
46    pub const fn from_raw(value: i32) -> Self {
47        Self(value)
48    }
49    #[inline]
50    pub const fn as_raw(self) -> i32 {
51        self.0
52    }
53}
54impl core::fmt::Debug for AccelerationStructureCompatibilityKHR {
55    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
56        match self.0 {
57            0i32 => f.write_str("COMPATIBLE"),
58            1i32 => f.write_str("INCOMPATIBLE"),
59            other => {
60                write!(
61                    f, "{}({})", stringify!(AccelerationStructureCompatibilityKHR), other
62                )
63            }
64        }
65    }
66}
67impl core::fmt::Display for AccelerationStructureCompatibilityKHR {
68    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
69        core::fmt::Debug::fmt(self, f)
70    }
71}
72impl core::error::Error for AccelerationStructureCompatibilityKHR {}
73///[`VkAccelerationStructureMemoryRequirementsTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMemoryRequirementsTypeNV.html)
74#[repr(transparent)]
75#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
76#[doc(alias = "VkAccelerationStructureMemoryRequirementsTypeNV")]
77pub struct AccelerationStructureMemoryRequirementsTypeNV(i32);
78impl AccelerationStructureMemoryRequirementsTypeNV {
79    pub const OBJECT: Self = Self(0i32);
80    pub const BUILD_SCRATCH: Self = Self(1i32);
81    pub const UPDATE_SCRATCH: Self = Self(2i32);
82    #[inline]
83    pub const fn from_raw(value: i32) -> Self {
84        Self(value)
85    }
86    #[inline]
87    pub const fn as_raw(self) -> i32 {
88        self.0
89    }
90}
91impl core::fmt::Debug for AccelerationStructureMemoryRequirementsTypeNV {
92    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
93        match self.0 {
94            0i32 => f.write_str("OBJECT"),
95            1i32 => f.write_str("BUILD_SCRATCH"),
96            2i32 => f.write_str("UPDATE_SCRATCH"),
97            other => {
98                write!(
99                    f, "{}({})",
100                    stringify!(AccelerationStructureMemoryRequirementsTypeNV), other
101                )
102            }
103        }
104    }
105}
106impl core::fmt::Display for AccelerationStructureMemoryRequirementsTypeNV {
107    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
108        core::fmt::Debug::fmt(self, f)
109    }
110}
111impl core::error::Error for AccelerationStructureMemoryRequirementsTypeNV {}
112///[`VkAccelerationStructureMotionInstanceTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceTypeNV.html)
113#[repr(transparent)]
114#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
115#[doc(alias = "VkAccelerationStructureMotionInstanceTypeNV")]
116pub struct AccelerationStructureMotionInstanceTypeNV(i32);
117impl AccelerationStructureMotionInstanceTypeNV {
118    pub const STATIC: Self = Self(0i32);
119    pub const MATRIX_MOTION: Self = Self(1i32);
120    pub const SRT_MOTION: Self = Self(2i32);
121    #[inline]
122    pub const fn from_raw(value: i32) -> Self {
123        Self(value)
124    }
125    #[inline]
126    pub const fn as_raw(self) -> i32 {
127        self.0
128    }
129}
130impl core::fmt::Debug for AccelerationStructureMotionInstanceTypeNV {
131    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
132        match self.0 {
133            0i32 => f.write_str("STATIC"),
134            1i32 => f.write_str("MATRIX_MOTION"),
135            2i32 => f.write_str("SRT_MOTION"),
136            other => {
137                write!(
138                    f, "{}({})", stringify!(AccelerationStructureMotionInstanceTypeNV),
139                    other
140                )
141            }
142        }
143    }
144}
145impl core::fmt::Display for AccelerationStructureMotionInstanceTypeNV {
146    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
147        core::fmt::Debug::fmt(self, f)
148    }
149}
150impl core::error::Error for AccelerationStructureMotionInstanceTypeNV {}
151///[`VkAccelerationStructureTypeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTypeKHR.html)
152#[repr(transparent)]
153#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
154#[doc(alias = "VkAccelerationStructureTypeKHR")]
155pub struct AccelerationStructureTypeKHR(i32);
156impl AccelerationStructureTypeKHR {
157    pub const TOP_LEVEL: Self = Self(0i32);
158    pub const BOTTOM_LEVEL: Self = Self(1i32);
159    pub const GENERIC: Self = Self(2i32);
160    #[inline]
161    pub const fn from_raw(value: i32) -> Self {
162        Self(value)
163    }
164    #[inline]
165    pub const fn as_raw(self) -> i32 {
166        self.0
167    }
168}
169impl core::fmt::Debug for AccelerationStructureTypeKHR {
170    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
171        match self.0 {
172            0i32 => f.write_str("TOP_LEVEL"),
173            1i32 => f.write_str("BOTTOM_LEVEL"),
174            2i32 => f.write_str("GENERIC"),
175            other => write!(f, "{}({})", stringify!(AccelerationStructureTypeKHR), other),
176        }
177    }
178}
179impl core::fmt::Display for AccelerationStructureTypeKHR {
180    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
181        core::fmt::Debug::fmt(self, f)
182    }
183}
184impl core::error::Error for AccelerationStructureTypeKHR {}
185///[`VkAntiLagModeAMD`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagModeAMD.html)
186#[repr(transparent)]
187#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
188#[doc(alias = "VkAntiLagModeAMD")]
189pub struct AntiLagModeAMD(i32);
190impl AntiLagModeAMD {
191    pub const DRIVER_CONTROL: Self = Self(0i32);
192    pub const ON: Self = Self(1i32);
193    pub const OFF: Self = Self(2i32);
194    #[inline]
195    pub const fn from_raw(value: i32) -> Self {
196        Self(value)
197    }
198    #[inline]
199    pub const fn as_raw(self) -> i32 {
200        self.0
201    }
202}
203impl core::fmt::Debug for AntiLagModeAMD {
204    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
205        match self.0 {
206            0i32 => f.write_str("DRIVER_CONTROL"),
207            1i32 => f.write_str("ON"),
208            2i32 => f.write_str("OFF"),
209            other => write!(f, "{}({})", stringify!(AntiLagModeAMD), other),
210        }
211    }
212}
213impl core::fmt::Display for AntiLagModeAMD {
214    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
215        core::fmt::Debug::fmt(self, f)
216    }
217}
218impl core::error::Error for AntiLagModeAMD {}
219///[`VkAntiLagStageAMD`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagStageAMD.html)
220#[repr(transparent)]
221#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
222#[doc(alias = "VkAntiLagStageAMD")]
223pub struct AntiLagStageAMD(i32);
224impl AntiLagStageAMD {
225    pub const INPUT: Self = Self(0i32);
226    pub const PRESENT: Self = Self(1i32);
227    #[inline]
228    pub const fn from_raw(value: i32) -> Self {
229        Self(value)
230    }
231    #[inline]
232    pub const fn as_raw(self) -> i32 {
233        self.0
234    }
235}
236impl core::fmt::Debug for AntiLagStageAMD {
237    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
238        match self.0 {
239            0i32 => f.write_str("INPUT"),
240            1i32 => f.write_str("PRESENT"),
241            other => write!(f, "{}({})", stringify!(AntiLagStageAMD), other),
242        }
243    }
244}
245impl core::fmt::Display for AntiLagStageAMD {
246    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
247        core::fmt::Debug::fmt(self, f)
248    }
249}
250impl core::error::Error for AntiLagStageAMD {}
251///[`VkAttachmentLoadOp`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentLoadOp.html)
252#[repr(transparent)]
253#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
254#[doc(alias = "VkAttachmentLoadOp")]
255pub struct AttachmentLoadOp(i32);
256impl AttachmentLoadOp {
257    pub const LOAD: Self = Self(0i32);
258    pub const CLEAR: Self = Self(1i32);
259    pub const DONT_CARE: Self = Self(2i32);
260    pub const NONE: Self = Self(1000400000i32);
261    #[inline]
262    pub const fn from_raw(value: i32) -> Self {
263        Self(value)
264    }
265    #[inline]
266    pub const fn as_raw(self) -> i32 {
267        self.0
268    }
269}
270impl core::fmt::Debug for AttachmentLoadOp {
271    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
272        match self.0 {
273            0i32 => f.write_str("LOAD"),
274            1i32 => f.write_str("CLEAR"),
275            2i32 => f.write_str("DONT_CARE"),
276            1000400000i32 => f.write_str("NONE"),
277            other => write!(f, "{}({})", stringify!(AttachmentLoadOp), other),
278        }
279    }
280}
281impl core::fmt::Display for AttachmentLoadOp {
282    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
283        core::fmt::Debug::fmt(self, f)
284    }
285}
286impl core::error::Error for AttachmentLoadOp {}
287///[`VkAttachmentStoreOp`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentStoreOp.html)
288#[repr(transparent)]
289#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
290#[doc(alias = "VkAttachmentStoreOp")]
291pub struct AttachmentStoreOp(i32);
292impl AttachmentStoreOp {
293    pub const STORE: Self = Self(0i32);
294    pub const DONT_CARE: Self = Self(1i32);
295    pub const NONE: Self = Self(1000301000i32);
296    #[inline]
297    pub const fn from_raw(value: i32) -> Self {
298        Self(value)
299    }
300    #[inline]
301    pub const fn as_raw(self) -> i32 {
302        self.0
303    }
304}
305impl core::fmt::Debug for AttachmentStoreOp {
306    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
307        match self.0 {
308            0i32 => f.write_str("STORE"),
309            1i32 => f.write_str("DONT_CARE"),
310            1000301000i32 => f.write_str("NONE"),
311            other => write!(f, "{}({})", stringify!(AttachmentStoreOp), other),
312        }
313    }
314}
315impl core::fmt::Display for AttachmentStoreOp {
316    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
317        core::fmt::Debug::fmt(self, f)
318    }
319}
320impl core::error::Error for AttachmentStoreOp {}
321///[`VkBlendFactor`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendFactor.html)
322#[repr(transparent)]
323#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
324#[doc(alias = "VkBlendFactor")]
325pub struct BlendFactor(i32);
326impl BlendFactor {
327    pub const ZERO: Self = Self(0i32);
328    pub const ONE: Self = Self(1i32);
329    pub const SRC_COLOR: Self = Self(2i32);
330    pub const ONE_MINUS_SRC_COLOR: Self = Self(3i32);
331    pub const DST_COLOR: Self = Self(4i32);
332    pub const ONE_MINUS_DST_COLOR: Self = Self(5i32);
333    pub const SRC_ALPHA: Self = Self(6i32);
334    pub const ONE_MINUS_SRC_ALPHA: Self = Self(7i32);
335    pub const DST_ALPHA: Self = Self(8i32);
336    pub const ONE_MINUS_DST_ALPHA: Self = Self(9i32);
337    pub const CONSTANT_COLOR: Self = Self(10i32);
338    pub const ONE_MINUS_CONSTANT_COLOR: Self = Self(11i32);
339    pub const CONSTANT_ALPHA: Self = Self(12i32);
340    pub const ONE_MINUS_CONSTANT_ALPHA: Self = Self(13i32);
341    pub const SRC_ALPHA_SATURATE: Self = Self(14i32);
342    pub const SRC1_COLOR: Self = Self(15i32);
343    pub const ONE_MINUS_SRC1_COLOR: Self = Self(16i32);
344    pub const SRC1_ALPHA: Self = Self(17i32);
345    pub const ONE_MINUS_SRC1_ALPHA: Self = Self(18i32);
346    #[inline]
347    pub const fn from_raw(value: i32) -> Self {
348        Self(value)
349    }
350    #[inline]
351    pub const fn as_raw(self) -> i32 {
352        self.0
353    }
354}
355impl core::fmt::Debug for BlendFactor {
356    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
357        match self.0 {
358            0i32 => f.write_str("ZERO"),
359            1i32 => f.write_str("ONE"),
360            2i32 => f.write_str("SRC_COLOR"),
361            3i32 => f.write_str("ONE_MINUS_SRC_COLOR"),
362            4i32 => f.write_str("DST_COLOR"),
363            5i32 => f.write_str("ONE_MINUS_DST_COLOR"),
364            6i32 => f.write_str("SRC_ALPHA"),
365            7i32 => f.write_str("ONE_MINUS_SRC_ALPHA"),
366            8i32 => f.write_str("DST_ALPHA"),
367            9i32 => f.write_str("ONE_MINUS_DST_ALPHA"),
368            10i32 => f.write_str("CONSTANT_COLOR"),
369            11i32 => f.write_str("ONE_MINUS_CONSTANT_COLOR"),
370            12i32 => f.write_str("CONSTANT_ALPHA"),
371            13i32 => f.write_str("ONE_MINUS_CONSTANT_ALPHA"),
372            14i32 => f.write_str("SRC_ALPHA_SATURATE"),
373            15i32 => f.write_str("SRC1_COLOR"),
374            16i32 => f.write_str("ONE_MINUS_SRC1_COLOR"),
375            17i32 => f.write_str("SRC1_ALPHA"),
376            18i32 => f.write_str("ONE_MINUS_SRC1_ALPHA"),
377            other => write!(f, "{}({})", stringify!(BlendFactor), other),
378        }
379    }
380}
381impl core::fmt::Display for BlendFactor {
382    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
383        core::fmt::Debug::fmt(self, f)
384    }
385}
386impl core::error::Error for BlendFactor {}
387///[`VkBlendOp`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendOp.html)
388#[repr(transparent)]
389#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
390#[doc(alias = "VkBlendOp")]
391pub struct BlendOp(i32);
392impl BlendOp {
393    pub const ADD: Self = Self(0i32);
394    pub const SUBTRACT: Self = Self(1i32);
395    pub const REVERSE_SUBTRACT: Self = Self(2i32);
396    pub const MIN: Self = Self(3i32);
397    pub const MAX: Self = Self(4i32);
398    pub const ZERO: Self = Self(1000148000i32);
399    pub const SRC: Self = Self(1000148001i32);
400    pub const DST: Self = Self(1000148002i32);
401    pub const SRC_OVER: Self = Self(1000148003i32);
402    pub const DST_OVER: Self = Self(1000148004i32);
403    pub const SRC_IN: Self = Self(1000148005i32);
404    pub const DST_IN: Self = Self(1000148006i32);
405    pub const SRC_OUT: Self = Self(1000148007i32);
406    pub const DST_OUT: Self = Self(1000148008i32);
407    pub const SRC_ATOP: Self = Self(1000148009i32);
408    pub const DST_ATOP: Self = Self(1000148010i32);
409    pub const XOR: Self = Self(1000148011i32);
410    pub const MULTIPLY: Self = Self(1000148012i32);
411    pub const SCREEN: Self = Self(1000148013i32);
412    pub const OVERLAY: Self = Self(1000148014i32);
413    pub const DARKEN: Self = Self(1000148015i32);
414    pub const LIGHTEN: Self = Self(1000148016i32);
415    pub const COLORDODGE: Self = Self(1000148017i32);
416    pub const COLORBURN: Self = Self(1000148018i32);
417    pub const HARDLIGHT: Self = Self(1000148019i32);
418    pub const SOFTLIGHT: Self = Self(1000148020i32);
419    pub const DIFFERENCE: Self = Self(1000148021i32);
420    pub const EXCLUSION: Self = Self(1000148022i32);
421    pub const INVERT: Self = Self(1000148023i32);
422    pub const INVERT_RGB: Self = Self(1000148024i32);
423    pub const LINEARDODGE: Self = Self(1000148025i32);
424    pub const LINEARBURN: Self = Self(1000148026i32);
425    pub const VIVIDLIGHT: Self = Self(1000148027i32);
426    pub const LINEARLIGHT: Self = Self(1000148028i32);
427    pub const PINLIGHT: Self = Self(1000148029i32);
428    pub const HARDMIX: Self = Self(1000148030i32);
429    pub const HSL_HUE: Self = Self(1000148031i32);
430    pub const HSL_SATURATION: Self = Self(1000148032i32);
431    pub const HSL_COLOR: Self = Self(1000148033i32);
432    pub const HSL_LUMINOSITY: Self = Self(1000148034i32);
433    pub const PLUS: Self = Self(1000148035i32);
434    pub const PLUS_CLAMPED: Self = Self(1000148036i32);
435    pub const PLUS_CLAMPED_ALPHA: Self = Self(1000148037i32);
436    pub const PLUS_DARKER: Self = Self(1000148038i32);
437    pub const MINUS: Self = Self(1000148039i32);
438    pub const MINUS_CLAMPED: Self = Self(1000148040i32);
439    pub const CONTRAST: Self = Self(1000148041i32);
440    pub const INVERT_OVG: Self = Self(1000148042i32);
441    pub const RED: Self = Self(1000148043i32);
442    pub const GREEN: Self = Self(1000148044i32);
443    pub const BLUE: Self = Self(1000148045i32);
444    #[inline]
445    pub const fn from_raw(value: i32) -> Self {
446        Self(value)
447    }
448    #[inline]
449    pub const fn as_raw(self) -> i32 {
450        self.0
451    }
452}
453impl core::fmt::Debug for BlendOp {
454    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
455        match self.0 {
456            0i32 => f.write_str("ADD"),
457            1i32 => f.write_str("SUBTRACT"),
458            2i32 => f.write_str("REVERSE_SUBTRACT"),
459            3i32 => f.write_str("MIN"),
460            4i32 => f.write_str("MAX"),
461            1000148000i32 => f.write_str("ZERO"),
462            1000148001i32 => f.write_str("SRC"),
463            1000148002i32 => f.write_str("DST"),
464            1000148003i32 => f.write_str("SRC_OVER"),
465            1000148004i32 => f.write_str("DST_OVER"),
466            1000148005i32 => f.write_str("SRC_IN"),
467            1000148006i32 => f.write_str("DST_IN"),
468            1000148007i32 => f.write_str("SRC_OUT"),
469            1000148008i32 => f.write_str("DST_OUT"),
470            1000148009i32 => f.write_str("SRC_ATOP"),
471            1000148010i32 => f.write_str("DST_ATOP"),
472            1000148011i32 => f.write_str("XOR"),
473            1000148012i32 => f.write_str("MULTIPLY"),
474            1000148013i32 => f.write_str("SCREEN"),
475            1000148014i32 => f.write_str("OVERLAY"),
476            1000148015i32 => f.write_str("DARKEN"),
477            1000148016i32 => f.write_str("LIGHTEN"),
478            1000148017i32 => f.write_str("COLORDODGE"),
479            1000148018i32 => f.write_str("COLORBURN"),
480            1000148019i32 => f.write_str("HARDLIGHT"),
481            1000148020i32 => f.write_str("SOFTLIGHT"),
482            1000148021i32 => f.write_str("DIFFERENCE"),
483            1000148022i32 => f.write_str("EXCLUSION"),
484            1000148023i32 => f.write_str("INVERT"),
485            1000148024i32 => f.write_str("INVERT_RGB"),
486            1000148025i32 => f.write_str("LINEARDODGE"),
487            1000148026i32 => f.write_str("LINEARBURN"),
488            1000148027i32 => f.write_str("VIVIDLIGHT"),
489            1000148028i32 => f.write_str("LINEARLIGHT"),
490            1000148029i32 => f.write_str("PINLIGHT"),
491            1000148030i32 => f.write_str("HARDMIX"),
492            1000148031i32 => f.write_str("HSL_HUE"),
493            1000148032i32 => f.write_str("HSL_SATURATION"),
494            1000148033i32 => f.write_str("HSL_COLOR"),
495            1000148034i32 => f.write_str("HSL_LUMINOSITY"),
496            1000148035i32 => f.write_str("PLUS"),
497            1000148036i32 => f.write_str("PLUS_CLAMPED"),
498            1000148037i32 => f.write_str("PLUS_CLAMPED_ALPHA"),
499            1000148038i32 => f.write_str("PLUS_DARKER"),
500            1000148039i32 => f.write_str("MINUS"),
501            1000148040i32 => f.write_str("MINUS_CLAMPED"),
502            1000148041i32 => f.write_str("CONTRAST"),
503            1000148042i32 => f.write_str("INVERT_OVG"),
504            1000148043i32 => f.write_str("RED"),
505            1000148044i32 => f.write_str("GREEN"),
506            1000148045i32 => f.write_str("BLUE"),
507            other => write!(f, "{}({})", stringify!(BlendOp), other),
508        }
509    }
510}
511impl core::fmt::Display for BlendOp {
512    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
513        core::fmt::Debug::fmt(self, f)
514    }
515}
516impl core::error::Error for BlendOp {}
517///[`VkBlendOverlapEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendOverlapEXT.html)
518#[repr(transparent)]
519#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
520#[doc(alias = "VkBlendOverlapEXT")]
521pub struct BlendOverlapEXT(i32);
522impl BlendOverlapEXT {
523    pub const UNCORRELATED: Self = Self(0i32);
524    pub const DISJOINT: Self = Self(1i32);
525    pub const CONJOINT: Self = Self(2i32);
526    #[inline]
527    pub const fn from_raw(value: i32) -> Self {
528        Self(value)
529    }
530    #[inline]
531    pub const fn as_raw(self) -> i32 {
532        self.0
533    }
534}
535impl core::fmt::Debug for BlendOverlapEXT {
536    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
537        match self.0 {
538            0i32 => f.write_str("UNCORRELATED"),
539            1i32 => f.write_str("DISJOINT"),
540            2i32 => f.write_str("CONJOINT"),
541            other => write!(f, "{}({})", stringify!(BlendOverlapEXT), other),
542        }
543    }
544}
545impl core::fmt::Display for BlendOverlapEXT {
546    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
547        core::fmt::Debug::fmt(self, f)
548    }
549}
550impl core::error::Error for BlendOverlapEXT {}
551///[`VkBlockMatchWindowCompareModeQCOM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlockMatchWindowCompareModeQCOM.html)
552#[repr(transparent)]
553#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
554#[doc(alias = "VkBlockMatchWindowCompareModeQCOM")]
555pub struct BlockMatchWindowCompareModeQCOM(i32);
556impl BlockMatchWindowCompareModeQCOM {
557    pub const MIN: Self = Self(0i32);
558    pub const MAX: Self = Self(1i32);
559    #[inline]
560    pub const fn from_raw(value: i32) -> Self {
561        Self(value)
562    }
563    #[inline]
564    pub const fn as_raw(self) -> i32 {
565        self.0
566    }
567}
568impl core::fmt::Debug for BlockMatchWindowCompareModeQCOM {
569    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
570        match self.0 {
571            0i32 => f.write_str("MIN"),
572            1i32 => f.write_str("MAX"),
573            other => {
574                write!(f, "{}({})", stringify!(BlockMatchWindowCompareModeQCOM), other)
575            }
576        }
577    }
578}
579impl core::fmt::Display for BlockMatchWindowCompareModeQCOM {
580    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
581        core::fmt::Debug::fmt(self, f)
582    }
583}
584impl core::error::Error for BlockMatchWindowCompareModeQCOM {}
585///[`VkBorderColor`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBorderColor.html)
586#[repr(transparent)]
587#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
588#[doc(alias = "VkBorderColor")]
589pub struct BorderColor(i32);
590impl BorderColor {
591    pub const FLOAT_TRANSPARENT_BLACK: Self = Self(0i32);
592    pub const INT_TRANSPARENT_BLACK: Self = Self(1i32);
593    pub const FLOAT_OPAQUE_BLACK: Self = Self(2i32);
594    pub const INT_OPAQUE_BLACK: Self = Self(3i32);
595    pub const FLOAT_OPAQUE_WHITE: Self = Self(4i32);
596    pub const INT_OPAQUE_WHITE: Self = Self(5i32);
597    pub const FLOAT_CUSTOM: Self = Self(1000287003i32);
598    pub const INT_CUSTOM: Self = Self(1000287004i32);
599    #[inline]
600    pub const fn from_raw(value: i32) -> Self {
601        Self(value)
602    }
603    #[inline]
604    pub const fn as_raw(self) -> i32 {
605        self.0
606    }
607}
608impl core::fmt::Debug for BorderColor {
609    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
610        match self.0 {
611            0i32 => f.write_str("FLOAT_TRANSPARENT_BLACK"),
612            1i32 => f.write_str("INT_TRANSPARENT_BLACK"),
613            2i32 => f.write_str("FLOAT_OPAQUE_BLACK"),
614            3i32 => f.write_str("INT_OPAQUE_BLACK"),
615            4i32 => f.write_str("FLOAT_OPAQUE_WHITE"),
616            5i32 => f.write_str("INT_OPAQUE_WHITE"),
617            1000287003i32 => f.write_str("FLOAT_CUSTOM"),
618            1000287004i32 => f.write_str("INT_CUSTOM"),
619            other => write!(f, "{}({})", stringify!(BorderColor), other),
620        }
621    }
622}
623impl core::fmt::Display for BorderColor {
624    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
625        core::fmt::Debug::fmt(self, f)
626    }
627}
628impl core::error::Error for BorderColor {}
629///[`VkBuildAccelerationStructureModeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildAccelerationStructureModeKHR.html)
630#[repr(transparent)]
631#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
632#[doc(alias = "VkBuildAccelerationStructureModeKHR")]
633pub struct BuildAccelerationStructureModeKHR(i32);
634impl BuildAccelerationStructureModeKHR {
635    pub const BUILD: Self = Self(0i32);
636    pub const UPDATE: Self = Self(1i32);
637    #[inline]
638    pub const fn from_raw(value: i32) -> Self {
639        Self(value)
640    }
641    #[inline]
642    pub const fn as_raw(self) -> i32 {
643        self.0
644    }
645}
646impl core::fmt::Debug for BuildAccelerationStructureModeKHR {
647    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
648        match self.0 {
649            0i32 => f.write_str("BUILD"),
650            1i32 => f.write_str("UPDATE"),
651            other => {
652                write!(f, "{}({})", stringify!(BuildAccelerationStructureModeKHR), other)
653            }
654        }
655    }
656}
657impl core::fmt::Display for BuildAccelerationStructureModeKHR {
658    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
659        core::fmt::Debug::fmt(self, f)
660    }
661}
662impl core::error::Error for BuildAccelerationStructureModeKHR {}
663///[`VkBuildMicromapModeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildMicromapModeEXT.html)
664#[repr(transparent)]
665#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
666#[doc(alias = "VkBuildMicromapModeEXT")]
667pub struct BuildMicromapModeEXT(i32);
668impl BuildMicromapModeEXT {
669    pub const BUILD: Self = Self(0i32);
670    #[inline]
671    pub const fn from_raw(value: i32) -> Self {
672        Self(value)
673    }
674    #[inline]
675    pub const fn as_raw(self) -> i32 {
676        self.0
677    }
678}
679impl core::fmt::Debug for BuildMicromapModeEXT {
680    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
681        match self.0 {
682            0i32 => f.write_str("BUILD"),
683            other => write!(f, "{}({})", stringify!(BuildMicromapModeEXT), other),
684        }
685    }
686}
687impl core::fmt::Display for BuildMicromapModeEXT {
688    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
689        core::fmt::Debug::fmt(self, f)
690    }
691}
692impl core::error::Error for BuildMicromapModeEXT {}
693///[`VkChromaLocation`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkChromaLocation.html)
694#[repr(transparent)]
695#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
696#[doc(alias = "VkChromaLocation")]
697pub struct ChromaLocation(i32);
698impl ChromaLocation {
699    pub const COSITED_EVEN: Self = Self(0i32);
700    pub const MIDPOINT: Self = Self(1i32);
701    #[inline]
702    pub const fn from_raw(value: i32) -> Self {
703        Self(value)
704    }
705    #[inline]
706    pub const fn as_raw(self) -> i32 {
707        self.0
708    }
709}
710impl core::fmt::Debug for ChromaLocation {
711    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
712        match self.0 {
713            0i32 => f.write_str("COSITED_EVEN"),
714            1i32 => f.write_str("MIDPOINT"),
715            other => write!(f, "{}({})", stringify!(ChromaLocation), other),
716        }
717    }
718}
719impl core::fmt::Display for ChromaLocation {
720    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
721        core::fmt::Debug::fmt(self, f)
722    }
723}
724impl core::error::Error for ChromaLocation {}
725///[`VkClusterAccelerationStructureOpModeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureOpModeNV.html)
726#[repr(transparent)]
727#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
728#[doc(alias = "VkClusterAccelerationStructureOpModeNV")]
729pub struct ClusterAccelerationStructureOpModeNV(i32);
730impl ClusterAccelerationStructureOpModeNV {
731    pub const IMPLICIT_DESTINATIONS: Self = Self(0i32);
732    pub const EXPLICIT_DESTINATIONS: Self = Self(1i32);
733    pub const COMPUTE_SIZES: Self = Self(2i32);
734    #[inline]
735    pub const fn from_raw(value: i32) -> Self {
736        Self(value)
737    }
738    #[inline]
739    pub const fn as_raw(self) -> i32 {
740        self.0
741    }
742}
743impl core::fmt::Debug for ClusterAccelerationStructureOpModeNV {
744    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
745        match self.0 {
746            0i32 => f.write_str("IMPLICIT_DESTINATIONS"),
747            1i32 => f.write_str("EXPLICIT_DESTINATIONS"),
748            2i32 => f.write_str("COMPUTE_SIZES"),
749            other => {
750                write!(
751                    f, "{}({})", stringify!(ClusterAccelerationStructureOpModeNV), other
752                )
753            }
754        }
755    }
756}
757impl core::fmt::Display for ClusterAccelerationStructureOpModeNV {
758    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
759        core::fmt::Debug::fmt(self, f)
760    }
761}
762impl core::error::Error for ClusterAccelerationStructureOpModeNV {}
763///[`VkClusterAccelerationStructureOpTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureOpTypeNV.html)
764#[repr(transparent)]
765#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
766#[doc(alias = "VkClusterAccelerationStructureOpTypeNV")]
767pub struct ClusterAccelerationStructureOpTypeNV(i32);
768impl ClusterAccelerationStructureOpTypeNV {
769    pub const MOVE_OBJECTS: Self = Self(0i32);
770    pub const BUILD_CLUSTERS_BOTTOM_LEVEL: Self = Self(1i32);
771    pub const BUILD_TRIANGLE_CLUSTER: Self = Self(2i32);
772    pub const BUILD_TRIANGLE_CLUSTER_TEMPLATE: Self = Self(3i32);
773    pub const INSTANTIATE_TRIANGLE_CLUSTER: Self = Self(4i32);
774    pub const GET_CLUSTER_TEMPLATE_INDICES: Self = Self(5i32);
775    #[inline]
776    pub const fn from_raw(value: i32) -> Self {
777        Self(value)
778    }
779    #[inline]
780    pub const fn as_raw(self) -> i32 {
781        self.0
782    }
783}
784impl core::fmt::Debug for ClusterAccelerationStructureOpTypeNV {
785    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
786        match self.0 {
787            0i32 => f.write_str("MOVE_OBJECTS"),
788            1i32 => f.write_str("BUILD_CLUSTERS_BOTTOM_LEVEL"),
789            2i32 => f.write_str("BUILD_TRIANGLE_CLUSTER"),
790            3i32 => f.write_str("BUILD_TRIANGLE_CLUSTER_TEMPLATE"),
791            4i32 => f.write_str("INSTANTIATE_TRIANGLE_CLUSTER"),
792            5i32 => f.write_str("GET_CLUSTER_TEMPLATE_INDICES"),
793            other => {
794                write!(
795                    f, "{}({})", stringify!(ClusterAccelerationStructureOpTypeNV), other
796                )
797            }
798        }
799    }
800}
801impl core::fmt::Display for ClusterAccelerationStructureOpTypeNV {
802    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
803        core::fmt::Debug::fmt(self, f)
804    }
805}
806impl core::error::Error for ClusterAccelerationStructureOpTypeNV {}
807///[`VkClusterAccelerationStructureTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureTypeNV.html)
808#[repr(transparent)]
809#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
810#[doc(alias = "VkClusterAccelerationStructureTypeNV")]
811pub struct ClusterAccelerationStructureTypeNV(i32);
812impl ClusterAccelerationStructureTypeNV {
813    pub const CLUSTERS_BOTTOM_LEVEL: Self = Self(0i32);
814    pub const TRIANGLE_CLUSTER: Self = Self(1i32);
815    pub const TRIANGLE_CLUSTER_TEMPLATE: Self = Self(2i32);
816    #[inline]
817    pub const fn from_raw(value: i32) -> Self {
818        Self(value)
819    }
820    #[inline]
821    pub const fn as_raw(self) -> i32 {
822        self.0
823    }
824}
825impl core::fmt::Debug for ClusterAccelerationStructureTypeNV {
826    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
827        match self.0 {
828            0i32 => f.write_str("CLUSTERS_BOTTOM_LEVEL"),
829            1i32 => f.write_str("TRIANGLE_CLUSTER"),
830            2i32 => f.write_str("TRIANGLE_CLUSTER_TEMPLATE"),
831            other => {
832                write!(
833                    f, "{}({})", stringify!(ClusterAccelerationStructureTypeNV), other
834                )
835            }
836        }
837    }
838}
839impl core::fmt::Display for ClusterAccelerationStructureTypeNV {
840    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
841        core::fmt::Debug::fmt(self, f)
842    }
843}
844impl core::error::Error for ClusterAccelerationStructureTypeNV {}
845///[`VkCoarseSampleOrderTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoarseSampleOrderTypeNV.html)
846#[repr(transparent)]
847#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
848#[doc(alias = "VkCoarseSampleOrderTypeNV")]
849pub struct CoarseSampleOrderTypeNV(i32);
850impl CoarseSampleOrderTypeNV {
851    pub const DEFAULT: Self = Self(0i32);
852    pub const CUSTOM: Self = Self(1i32);
853    pub const PIXEL_MAJOR: Self = Self(2i32);
854    pub const SAMPLE_MAJOR: Self = Self(3i32);
855    #[inline]
856    pub const fn from_raw(value: i32) -> Self {
857        Self(value)
858    }
859    #[inline]
860    pub const fn as_raw(self) -> i32 {
861        self.0
862    }
863}
864impl core::fmt::Debug for CoarseSampleOrderTypeNV {
865    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
866        match self.0 {
867            0i32 => f.write_str("DEFAULT"),
868            1i32 => f.write_str("CUSTOM"),
869            2i32 => f.write_str("PIXEL_MAJOR"),
870            3i32 => f.write_str("SAMPLE_MAJOR"),
871            other => write!(f, "{}({})", stringify!(CoarseSampleOrderTypeNV), other),
872        }
873    }
874}
875impl core::fmt::Display for CoarseSampleOrderTypeNV {
876    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
877        core::fmt::Debug::fmt(self, f)
878    }
879}
880impl core::error::Error for CoarseSampleOrderTypeNV {}
881///[`VkColorSpaceKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorSpaceKHR.html)
882#[repr(transparent)]
883#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
884#[doc(alias = "VkColorSpaceKHR")]
885pub struct ColorSpaceKHR(i32);
886impl ColorSpaceKHR {
887    pub const SRGB_NONLINEAR: Self = Self(0i32);
888    pub const COLORSPACE_SRGB_NONLINEAR: Self = Self::SRGB_NONLINEAR;
889    pub const DISPLAY_P3_NONLINEAR: Self = Self(1000104001i32);
890    pub const EXTENDED_SRGB_LINEAR: Self = Self(1000104002i32);
891    pub const DISPLAY_P3_LINEAR: Self = Self(1000104003i32);
892    pub const DCI_P3_NONLINEAR: Self = Self(1000104004i32);
893    pub const BT709_LINEAR: Self = Self(1000104005i32);
894    pub const BT709_NONLINEAR: Self = Self(1000104006i32);
895    pub const BT2020_LINEAR: Self = Self(1000104007i32);
896    pub const HDR10_ST2084: Self = Self(1000104008i32);
897    pub const DOLBYVISION: Self = Self(1000104009i32);
898    pub const HDR10_HLG: Self = Self(1000104010i32);
899    pub const ADOBERGB_LINEAR: Self = Self(1000104011i32);
900    pub const ADOBERGB_NONLINEAR: Self = Self(1000104012i32);
901    pub const PASS_THROUGH: Self = Self(1000104013i32);
902    pub const EXTENDED_SRGB_NONLINEAR: Self = Self(1000104014i32);
903    pub const DCI_P3_LINEAR: Self = Self::DISPLAY_P3_LINEAR;
904    pub const DISPLAY_NATIVE: Self = Self(1000213000i32);
905    #[inline]
906    pub const fn from_raw(value: i32) -> Self {
907        Self(value)
908    }
909    #[inline]
910    pub const fn as_raw(self) -> i32 {
911        self.0
912    }
913}
914impl core::fmt::Debug for ColorSpaceKHR {
915    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
916        match self.0 {
917            0i32 => f.write_str("SRGB_NONLINEAR"),
918            1000104001i32 => f.write_str("DISPLAY_P3_NONLINEAR"),
919            1000104002i32 => f.write_str("EXTENDED_SRGB_LINEAR"),
920            1000104003i32 => f.write_str("DISPLAY_P3_LINEAR"),
921            1000104004i32 => f.write_str("DCI_P3_NONLINEAR"),
922            1000104005i32 => f.write_str("BT709_LINEAR"),
923            1000104006i32 => f.write_str("BT709_NONLINEAR"),
924            1000104007i32 => f.write_str("BT2020_LINEAR"),
925            1000104008i32 => f.write_str("HDR10_ST2084"),
926            1000104009i32 => f.write_str("DOLBYVISION"),
927            1000104010i32 => f.write_str("HDR10_HLG"),
928            1000104011i32 => f.write_str("ADOBERGB_LINEAR"),
929            1000104012i32 => f.write_str("ADOBERGB_NONLINEAR"),
930            1000104013i32 => f.write_str("PASS_THROUGH"),
931            1000104014i32 => f.write_str("EXTENDED_SRGB_NONLINEAR"),
932            1000213000i32 => f.write_str("DISPLAY_NATIVE"),
933            other => write!(f, "{}({})", stringify!(ColorSpaceKHR), other),
934        }
935    }
936}
937impl core::fmt::Display for ColorSpaceKHR {
938    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
939        core::fmt::Debug::fmt(self, f)
940    }
941}
942impl core::error::Error for ColorSpaceKHR {}
943///[`VkCommandBufferLevel`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferLevel.html)
944#[repr(transparent)]
945#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
946#[doc(alias = "VkCommandBufferLevel")]
947pub struct CommandBufferLevel(i32);
948impl CommandBufferLevel {
949    pub const PRIMARY: Self = Self(0i32);
950    pub const SECONDARY: Self = Self(1i32);
951    #[inline]
952    pub const fn from_raw(value: i32) -> Self {
953        Self(value)
954    }
955    #[inline]
956    pub const fn as_raw(self) -> i32 {
957        self.0
958    }
959}
960impl core::fmt::Debug for CommandBufferLevel {
961    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
962        match self.0 {
963            0i32 => f.write_str("PRIMARY"),
964            1i32 => f.write_str("SECONDARY"),
965            other => write!(f, "{}({})", stringify!(CommandBufferLevel), other),
966        }
967    }
968}
969impl core::fmt::Display for CommandBufferLevel {
970    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
971        core::fmt::Debug::fmt(self, f)
972    }
973}
974impl core::error::Error for CommandBufferLevel {}
975///[`VkCompareOp`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompareOp.html)
976#[repr(transparent)]
977#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
978#[doc(alias = "VkCompareOp")]
979pub struct CompareOp(i32);
980impl CompareOp {
981    pub const NEVER: Self = Self(0i32);
982    pub const LESS: Self = Self(1i32);
983    pub const EQUAL: Self = Self(2i32);
984    pub const LESS_OR_EQUAL: Self = Self(3i32);
985    pub const GREATER: Self = Self(4i32);
986    pub const NOT_EQUAL: Self = Self(5i32);
987    pub const GREATER_OR_EQUAL: Self = Self(6i32);
988    pub const ALWAYS: Self = Self(7i32);
989    #[inline]
990    pub const fn from_raw(value: i32) -> Self {
991        Self(value)
992    }
993    #[inline]
994    pub const fn as_raw(self) -> i32 {
995        self.0
996    }
997}
998impl core::fmt::Debug for CompareOp {
999    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1000        match self.0 {
1001            0i32 => f.write_str("NEVER"),
1002            1i32 => f.write_str("LESS"),
1003            2i32 => f.write_str("EQUAL"),
1004            3i32 => f.write_str("LESS_OR_EQUAL"),
1005            4i32 => f.write_str("GREATER"),
1006            5i32 => f.write_str("NOT_EQUAL"),
1007            6i32 => f.write_str("GREATER_OR_EQUAL"),
1008            7i32 => f.write_str("ALWAYS"),
1009            other => write!(f, "{}({})", stringify!(CompareOp), other),
1010        }
1011    }
1012}
1013impl core::fmt::Display for CompareOp {
1014    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1015        core::fmt::Debug::fmt(self, f)
1016    }
1017}
1018impl core::error::Error for CompareOp {}
1019///[`VkComponentSwizzle`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentSwizzle.html)
1020#[repr(transparent)]
1021#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1022#[doc(alias = "VkComponentSwizzle")]
1023pub struct ComponentSwizzle(i32);
1024impl ComponentSwizzle {
1025    pub const IDENTITY: Self = Self(0i32);
1026    pub const ZERO: Self = Self(1i32);
1027    pub const ONE: Self = Self(2i32);
1028    pub const R: Self = Self(3i32);
1029    pub const G: Self = Self(4i32);
1030    pub const B: Self = Self(5i32);
1031    pub const A: Self = Self(6i32);
1032    #[inline]
1033    pub const fn from_raw(value: i32) -> Self {
1034        Self(value)
1035    }
1036    #[inline]
1037    pub const fn as_raw(self) -> i32 {
1038        self.0
1039    }
1040}
1041impl core::fmt::Debug for ComponentSwizzle {
1042    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1043        match self.0 {
1044            0i32 => f.write_str("IDENTITY"),
1045            1i32 => f.write_str("ZERO"),
1046            2i32 => f.write_str("ONE"),
1047            3i32 => f.write_str("R"),
1048            4i32 => f.write_str("G"),
1049            5i32 => f.write_str("B"),
1050            6i32 => f.write_str("A"),
1051            other => write!(f, "{}({})", stringify!(ComponentSwizzle), other),
1052        }
1053    }
1054}
1055impl core::fmt::Display for ComponentSwizzle {
1056    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1057        core::fmt::Debug::fmt(self, f)
1058    }
1059}
1060impl core::error::Error for ComponentSwizzle {}
1061///[`VkComponentTypeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentTypeKHR.html)
1062#[repr(transparent)]
1063#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1064#[doc(alias = "VkComponentTypeKHR")]
1065pub struct ComponentTypeKHR(i32);
1066impl ComponentTypeKHR {
1067    pub const FLOAT16: Self = Self(0i32);
1068    pub const FLOAT32: Self = Self(1i32);
1069    pub const FLOAT64: Self = Self(2i32);
1070    pub const SINT8: Self = Self(3i32);
1071    pub const SINT16: Self = Self(4i32);
1072    pub const SINT32: Self = Self(5i32);
1073    pub const SINT64: Self = Self(6i32);
1074    pub const UINT8: Self = Self(7i32);
1075    pub const UINT16: Self = Self(8i32);
1076    pub const UINT32: Self = Self(9i32);
1077    pub const UINT64: Self = Self(10i32);
1078    pub const BFLOAT16: Self = Self(1000141000i32);
1079    pub const SINT8_PACKED: Self = Self(1000491000i32);
1080    pub const UINT8_PACKED: Self = Self(1000491001i32);
1081    pub const FLOAT_E4M3: Self = Self::FLOAT8_E4M3;
1082    pub const FLOAT_E5M2: Self = Self::FLOAT8_E5M2;
1083    pub const FLOAT8_E4M3: Self = Self(1000491002i32);
1084    pub const FLOAT8_E5M2: Self = Self(1000491003i32);
1085    #[inline]
1086    pub const fn from_raw(value: i32) -> Self {
1087        Self(value)
1088    }
1089    #[inline]
1090    pub const fn as_raw(self) -> i32 {
1091        self.0
1092    }
1093}
1094impl core::fmt::Debug for ComponentTypeKHR {
1095    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1096        match self.0 {
1097            0i32 => f.write_str("FLOAT16"),
1098            1i32 => f.write_str("FLOAT32"),
1099            2i32 => f.write_str("FLOAT64"),
1100            3i32 => f.write_str("SINT8"),
1101            4i32 => f.write_str("SINT16"),
1102            5i32 => f.write_str("SINT32"),
1103            6i32 => f.write_str("SINT64"),
1104            7i32 => f.write_str("UINT8"),
1105            8i32 => f.write_str("UINT16"),
1106            9i32 => f.write_str("UINT32"),
1107            10i32 => f.write_str("UINT64"),
1108            1000141000i32 => f.write_str("BFLOAT16"),
1109            1000491000i32 => f.write_str("SINT8_PACKED"),
1110            1000491001i32 => f.write_str("UINT8_PACKED"),
1111            1000491002i32 => f.write_str("FLOAT8_E4M3"),
1112            1000491003i32 => f.write_str("FLOAT8_E5M2"),
1113            other => write!(f, "{}({})", stringify!(ComponentTypeKHR), other),
1114        }
1115    }
1116}
1117impl core::fmt::Display for ComponentTypeKHR {
1118    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1119        core::fmt::Debug::fmt(self, f)
1120    }
1121}
1122impl core::error::Error for ComponentTypeKHR {}
1123///[`VkCompressedTriangleFormatAMDX`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompressedTriangleFormatAMDX.html)
1124#[repr(transparent)]
1125#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1126#[doc(alias = "VkCompressedTriangleFormatAMDX")]
1127pub struct CompressedTriangleFormatAMDX(i32);
1128impl CompressedTriangleFormatAMDX {
1129    pub const DGF1: Self = Self(0i32);
1130    #[inline]
1131    pub const fn from_raw(value: i32) -> Self {
1132        Self(value)
1133    }
1134    #[inline]
1135    pub const fn as_raw(self) -> i32 {
1136        self.0
1137    }
1138}
1139impl core::fmt::Debug for CompressedTriangleFormatAMDX {
1140    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1141        match self.0 {
1142            0i32 => f.write_str("DGF1"),
1143            other => write!(f, "{}({})", stringify!(CompressedTriangleFormatAMDX), other),
1144        }
1145    }
1146}
1147impl core::fmt::Display for CompressedTriangleFormatAMDX {
1148    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1149        core::fmt::Debug::fmt(self, f)
1150    }
1151}
1152impl core::error::Error for CompressedTriangleFormatAMDX {}
1153///[`VkConservativeRasterizationModeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkConservativeRasterizationModeEXT.html)
1154#[repr(transparent)]
1155#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1156#[doc(alias = "VkConservativeRasterizationModeEXT")]
1157pub struct ConservativeRasterizationModeEXT(i32);
1158impl ConservativeRasterizationModeEXT {
1159    pub const DISABLED: Self = Self(0i32);
1160    pub const OVERESTIMATE: Self = Self(1i32);
1161    pub const UNDERESTIMATE: Self = Self(2i32);
1162    #[inline]
1163    pub const fn from_raw(value: i32) -> Self {
1164        Self(value)
1165    }
1166    #[inline]
1167    pub const fn as_raw(self) -> i32 {
1168        self.0
1169    }
1170}
1171impl core::fmt::Debug for ConservativeRasterizationModeEXT {
1172    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1173        match self.0 {
1174            0i32 => f.write_str("DISABLED"),
1175            1i32 => f.write_str("OVERESTIMATE"),
1176            2i32 => f.write_str("UNDERESTIMATE"),
1177            other => {
1178                write!(f, "{}({})", stringify!(ConservativeRasterizationModeEXT), other)
1179            }
1180        }
1181    }
1182}
1183impl core::fmt::Display for ConservativeRasterizationModeEXT {
1184    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1185        core::fmt::Debug::fmt(self, f)
1186    }
1187}
1188impl core::error::Error for ConservativeRasterizationModeEXT {}
1189///[`VkCooperativeVectorMatrixLayoutNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeVectorMatrixLayoutNV.html)
1190#[repr(transparent)]
1191#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1192#[doc(alias = "VkCooperativeVectorMatrixLayoutNV")]
1193pub struct CooperativeVectorMatrixLayoutNV(i32);
1194impl CooperativeVectorMatrixLayoutNV {
1195    pub const ROW_MAJOR: Self = Self(0i32);
1196    pub const COLUMN_MAJOR: Self = Self(1i32);
1197    pub const INFERENCING_OPTIMAL: Self = Self(2i32);
1198    pub const TRAINING_OPTIMAL: Self = Self(3i32);
1199    #[inline]
1200    pub const fn from_raw(value: i32) -> Self {
1201        Self(value)
1202    }
1203    #[inline]
1204    pub const fn as_raw(self) -> i32 {
1205        self.0
1206    }
1207}
1208impl core::fmt::Debug for CooperativeVectorMatrixLayoutNV {
1209    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1210        match self.0 {
1211            0i32 => f.write_str("ROW_MAJOR"),
1212            1i32 => f.write_str("COLUMN_MAJOR"),
1213            2i32 => f.write_str("INFERENCING_OPTIMAL"),
1214            3i32 => f.write_str("TRAINING_OPTIMAL"),
1215            other => {
1216                write!(f, "{}({})", stringify!(CooperativeVectorMatrixLayoutNV), other)
1217            }
1218        }
1219    }
1220}
1221impl core::fmt::Display for CooperativeVectorMatrixLayoutNV {
1222    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1223        core::fmt::Debug::fmt(self, f)
1224    }
1225}
1226impl core::error::Error for CooperativeVectorMatrixLayoutNV {}
1227///[`VkCopyAccelerationStructureModeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyAccelerationStructureModeKHR.html)
1228#[repr(transparent)]
1229#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1230#[doc(alias = "VkCopyAccelerationStructureModeKHR")]
1231pub struct CopyAccelerationStructureModeKHR(i32);
1232impl CopyAccelerationStructureModeKHR {
1233    pub const CLONE: Self = Self(0i32);
1234    pub const COMPACT: Self = Self(1i32);
1235    pub const SERIALIZE: Self = Self(2i32);
1236    pub const DESERIALIZE: Self = Self(3i32);
1237    #[inline]
1238    pub const fn from_raw(value: i32) -> Self {
1239        Self(value)
1240    }
1241    #[inline]
1242    pub const fn as_raw(self) -> i32 {
1243        self.0
1244    }
1245}
1246impl core::fmt::Debug for CopyAccelerationStructureModeKHR {
1247    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1248        match self.0 {
1249            0i32 => f.write_str("CLONE"),
1250            1i32 => f.write_str("COMPACT"),
1251            2i32 => f.write_str("SERIALIZE"),
1252            3i32 => f.write_str("DESERIALIZE"),
1253            other => {
1254                write!(f, "{}({})", stringify!(CopyAccelerationStructureModeKHR), other)
1255            }
1256        }
1257    }
1258}
1259impl core::fmt::Display for CopyAccelerationStructureModeKHR {
1260    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1261        core::fmt::Debug::fmt(self, f)
1262    }
1263}
1264impl core::error::Error for CopyAccelerationStructureModeKHR {}
1265///[`VkCopyMicromapModeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMicromapModeEXT.html)
1266#[repr(transparent)]
1267#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1268#[doc(alias = "VkCopyMicromapModeEXT")]
1269pub struct CopyMicromapModeEXT(i32);
1270impl CopyMicromapModeEXT {
1271    pub const CLONE: Self = Self(0i32);
1272    pub const SERIALIZE: Self = Self(1i32);
1273    pub const DESERIALIZE: Self = Self(2i32);
1274    pub const COMPACT: Self = Self(3i32);
1275    #[inline]
1276    pub const fn from_raw(value: i32) -> Self {
1277        Self(value)
1278    }
1279    #[inline]
1280    pub const fn as_raw(self) -> i32 {
1281        self.0
1282    }
1283}
1284impl core::fmt::Debug for CopyMicromapModeEXT {
1285    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1286        match self.0 {
1287            0i32 => f.write_str("CLONE"),
1288            1i32 => f.write_str("SERIALIZE"),
1289            2i32 => f.write_str("DESERIALIZE"),
1290            3i32 => f.write_str("COMPACT"),
1291            other => write!(f, "{}({})", stringify!(CopyMicromapModeEXT), other),
1292        }
1293    }
1294}
1295impl core::fmt::Display for CopyMicromapModeEXT {
1296    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1297        core::fmt::Debug::fmt(self, f)
1298    }
1299}
1300impl core::error::Error for CopyMicromapModeEXT {}
1301///[`VkCoverageModulationModeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoverageModulationModeNV.html)
1302#[repr(transparent)]
1303#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1304#[doc(alias = "VkCoverageModulationModeNV")]
1305pub struct CoverageModulationModeNV(i32);
1306impl CoverageModulationModeNV {
1307    pub const NONE: Self = Self(0i32);
1308    pub const RGB: Self = Self(1i32);
1309    pub const ALPHA: Self = Self(2i32);
1310    pub const RGBA: Self = Self(3i32);
1311    #[inline]
1312    pub const fn from_raw(value: i32) -> Self {
1313        Self(value)
1314    }
1315    #[inline]
1316    pub const fn as_raw(self) -> i32 {
1317        self.0
1318    }
1319}
1320impl core::fmt::Debug for CoverageModulationModeNV {
1321    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1322        match self.0 {
1323            0i32 => f.write_str("NONE"),
1324            1i32 => f.write_str("RGB"),
1325            2i32 => f.write_str("ALPHA"),
1326            3i32 => f.write_str("RGBA"),
1327            other => write!(f, "{}({})", stringify!(CoverageModulationModeNV), other),
1328        }
1329    }
1330}
1331impl core::fmt::Display for CoverageModulationModeNV {
1332    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1333        core::fmt::Debug::fmt(self, f)
1334    }
1335}
1336impl core::error::Error for CoverageModulationModeNV {}
1337///[`VkCoverageReductionModeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoverageReductionModeNV.html)
1338#[repr(transparent)]
1339#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1340#[doc(alias = "VkCoverageReductionModeNV")]
1341pub struct CoverageReductionModeNV(i32);
1342impl CoverageReductionModeNV {
1343    pub const MERGE: Self = Self(0i32);
1344    pub const TRUNCATE: Self = Self(1i32);
1345    #[inline]
1346    pub const fn from_raw(value: i32) -> Self {
1347        Self(value)
1348    }
1349    #[inline]
1350    pub const fn as_raw(self) -> i32 {
1351        self.0
1352    }
1353}
1354impl core::fmt::Debug for CoverageReductionModeNV {
1355    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1356        match self.0 {
1357            0i32 => f.write_str("MERGE"),
1358            1i32 => f.write_str("TRUNCATE"),
1359            other => write!(f, "{}({})", stringify!(CoverageReductionModeNV), other),
1360        }
1361    }
1362}
1363impl core::fmt::Display for CoverageReductionModeNV {
1364    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1365        core::fmt::Debug::fmt(self, f)
1366    }
1367}
1368impl core::error::Error for CoverageReductionModeNV {}
1369///[`VkCubicFilterWeightsQCOM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkCubicFilterWeightsQCOM.html)
1370#[repr(transparent)]
1371#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1372#[doc(alias = "VkCubicFilterWeightsQCOM")]
1373pub struct CubicFilterWeightsQCOM(i32);
1374impl CubicFilterWeightsQCOM {
1375    pub const CATMULL_ROM: Self = Self(0i32);
1376    pub const ZERO_TANGENT_CARDINAL: Self = Self(1i32);
1377    pub const B_SPLINE: Self = Self(2i32);
1378    pub const MITCHELL_NETRAVALI: Self = Self(3i32);
1379    #[inline]
1380    pub const fn from_raw(value: i32) -> Self {
1381        Self(value)
1382    }
1383    #[inline]
1384    pub const fn as_raw(self) -> i32 {
1385        self.0
1386    }
1387}
1388impl core::fmt::Debug for CubicFilterWeightsQCOM {
1389    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1390        match self.0 {
1391            0i32 => f.write_str("CATMULL_ROM"),
1392            1i32 => f.write_str("ZERO_TANGENT_CARDINAL"),
1393            2i32 => f.write_str("B_SPLINE"),
1394            3i32 => f.write_str("MITCHELL_NETRAVALI"),
1395            other => write!(f, "{}({})", stringify!(CubicFilterWeightsQCOM), other),
1396        }
1397    }
1398}
1399impl core::fmt::Display for CubicFilterWeightsQCOM {
1400    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1401        core::fmt::Debug::fmt(self, f)
1402    }
1403}
1404impl core::error::Error for CubicFilterWeightsQCOM {}
1405///[`VkDataGraphModelCacheTypeQCOM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphModelCacheTypeQCOM.html)
1406#[repr(transparent)]
1407#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1408#[doc(alias = "VkDataGraphModelCacheTypeQCOM")]
1409pub struct DataGraphModelCacheTypeQCOM(i32);
1410impl DataGraphModelCacheTypeQCOM {
1411    pub const GENERIC_BINARY: Self = Self(0i32);
1412    #[inline]
1413    pub const fn from_raw(value: i32) -> Self {
1414        Self(value)
1415    }
1416    #[inline]
1417    pub const fn as_raw(self) -> i32 {
1418        self.0
1419    }
1420}
1421impl core::fmt::Debug for DataGraphModelCacheTypeQCOM {
1422    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1423        match self.0 {
1424            0i32 => f.write_str("GENERIC_BINARY"),
1425            other => write!(f, "{}({})", stringify!(DataGraphModelCacheTypeQCOM), other),
1426        }
1427    }
1428}
1429impl core::fmt::Display for DataGraphModelCacheTypeQCOM {
1430    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1431        core::fmt::Debug::fmt(self, f)
1432    }
1433}
1434impl core::error::Error for DataGraphModelCacheTypeQCOM {}
1435///[`VkDataGraphPipelinePropertyARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelinePropertyARM.html)
1436#[repr(transparent)]
1437#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1438#[doc(alias = "VkDataGraphPipelinePropertyARM")]
1439pub struct DataGraphPipelinePropertyARM(i32);
1440impl DataGraphPipelinePropertyARM {
1441    pub const CREATION_LOG: Self = Self(0i32);
1442    pub const IDENTIFIER: Self = Self(1i32);
1443    #[inline]
1444    pub const fn from_raw(value: i32) -> Self {
1445        Self(value)
1446    }
1447    #[inline]
1448    pub const fn as_raw(self) -> i32 {
1449        self.0
1450    }
1451}
1452impl core::fmt::Debug for DataGraphPipelinePropertyARM {
1453    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1454        match self.0 {
1455            0i32 => f.write_str("CREATION_LOG"),
1456            1i32 => f.write_str("IDENTIFIER"),
1457            other => write!(f, "{}({})", stringify!(DataGraphPipelinePropertyARM), other),
1458        }
1459    }
1460}
1461impl core::fmt::Display for DataGraphPipelinePropertyARM {
1462    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1463        core::fmt::Debug::fmt(self, f)
1464    }
1465}
1466impl core::error::Error for DataGraphPipelinePropertyARM {}
1467///[`VkDataGraphPipelineSessionBindPointARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointARM.html)
1468#[repr(transparent)]
1469#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1470#[doc(alias = "VkDataGraphPipelineSessionBindPointARM")]
1471pub struct DataGraphPipelineSessionBindPointARM(i32);
1472impl DataGraphPipelineSessionBindPointARM {
1473    pub const TRANSIENT: Self = Self(0i32);
1474    #[inline]
1475    pub const fn from_raw(value: i32) -> Self {
1476        Self(value)
1477    }
1478    #[inline]
1479    pub const fn as_raw(self) -> i32 {
1480        self.0
1481    }
1482}
1483impl core::fmt::Debug for DataGraphPipelineSessionBindPointARM {
1484    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1485        match self.0 {
1486            0i32 => f.write_str("TRANSIENT"),
1487            other => {
1488                write!(
1489                    f, "{}({})", stringify!(DataGraphPipelineSessionBindPointARM), other
1490                )
1491            }
1492        }
1493    }
1494}
1495impl core::fmt::Display for DataGraphPipelineSessionBindPointARM {
1496    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1497        core::fmt::Debug::fmt(self, f)
1498    }
1499}
1500impl core::error::Error for DataGraphPipelineSessionBindPointARM {}
1501///[`VkDataGraphPipelineSessionBindPointTypeARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointTypeARM.html)
1502#[repr(transparent)]
1503#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1504#[doc(alias = "VkDataGraphPipelineSessionBindPointTypeARM")]
1505pub struct DataGraphPipelineSessionBindPointTypeARM(i32);
1506impl DataGraphPipelineSessionBindPointTypeARM {
1507    pub const MEMORY: Self = Self(0i32);
1508    #[inline]
1509    pub const fn from_raw(value: i32) -> Self {
1510        Self(value)
1511    }
1512    #[inline]
1513    pub const fn as_raw(self) -> i32 {
1514        self.0
1515    }
1516}
1517impl core::fmt::Debug for DataGraphPipelineSessionBindPointTypeARM {
1518    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1519        match self.0 {
1520            0i32 => f.write_str("MEMORY"),
1521            other => {
1522                write!(
1523                    f, "{}({})", stringify!(DataGraphPipelineSessionBindPointTypeARM),
1524                    other
1525                )
1526            }
1527        }
1528    }
1529}
1530impl core::fmt::Display for DataGraphPipelineSessionBindPointTypeARM {
1531    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1532        core::fmt::Debug::fmt(self, f)
1533    }
1534}
1535impl core::error::Error for DataGraphPipelineSessionBindPointTypeARM {}
1536///[`VkDebugReportObjectTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportObjectTypeEXT.html)
1537#[repr(transparent)]
1538#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1539#[doc(alias = "VkDebugReportObjectTypeEXT")]
1540pub struct DebugReportObjectTypeEXT(i32);
1541impl DebugReportObjectTypeEXT {
1542    pub const UNKNOWN: Self = Self(0i32);
1543    pub const INSTANCE: Self = Self(1i32);
1544    pub const PHYSICAL_DEVICE: Self = Self(2i32);
1545    pub const DEVICE: Self = Self(3i32);
1546    pub const QUEUE: Self = Self(4i32);
1547    pub const SEMAPHORE: Self = Self(5i32);
1548    pub const COMMAND_BUFFER: Self = Self(6i32);
1549    pub const FENCE: Self = Self(7i32);
1550    pub const DEVICE_MEMORY: Self = Self(8i32);
1551    pub const BUFFER: Self = Self(9i32);
1552    pub const IMAGE: Self = Self(10i32);
1553    pub const EVENT: Self = Self(11i32);
1554    pub const QUERY_POOL: Self = Self(12i32);
1555    pub const BUFFER_VIEW: Self = Self(13i32);
1556    pub const IMAGE_VIEW: Self = Self(14i32);
1557    pub const SHADER_MODULE: Self = Self(15i32);
1558    pub const PIPELINE_CACHE: Self = Self(16i32);
1559    pub const PIPELINE_LAYOUT: Self = Self(17i32);
1560    pub const RENDER_PASS: Self = Self(18i32);
1561    pub const PIPELINE: Self = Self(19i32);
1562    pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20i32);
1563    pub const SAMPLER: Self = Self(21i32);
1564    pub const DESCRIPTOR_POOL: Self = Self(22i32);
1565    pub const DESCRIPTOR_SET: Self = Self(23i32);
1566    pub const FRAMEBUFFER: Self = Self(24i32);
1567    pub const COMMAND_POOL: Self = Self(25i32);
1568    pub const SURFACE_: Self = Self(26i32);
1569    pub const SWAPCHAIN_: Self = Self(27i32);
1570    pub const DEBUG_REPORT_CALLBACK_: Self = Self(28i32);
1571    pub const DEBUG_REPORT: Self = Self::DEBUG_REPORT_CALLBACK_;
1572    pub const DISPLAY_: Self = Self(29i32);
1573    pub const DISPLAY_MODE_: Self = Self(30i32);
1574    pub const VALIDATION_CACHE_: Self = Self(33i32);
1575    pub const VALIDATION_CACHE: Self = Self::VALIDATION_CACHE_;
1576    pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1000156000i32);
1577    pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1000085000i32);
1578    pub const CU_MODULE_: Self = Self(1000029000i32);
1579    pub const CU_FUNCTION_: Self = Self(1000029001i32);
1580    pub const DESCRIPTOR_UPDATE_TEMPLATE_: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE;
1581    pub const ACCELERATION_STRUCTURE_: Self = Self(1000150000i32);
1582    pub const SAMPLER_YCBCR_CONVERSION_: Self = Self::SAMPLER_YCBCR_CONVERSION;
1583    pub const CUDA_MODULE_: Self = Self(1000307000i32);
1584    pub const CUDA_FUNCTION_: Self = Self(1000307001i32);
1585    pub const BUFFER_COLLECTION_: Self = Self(1000366000i32);
1586    #[inline]
1587    pub const fn from_raw(value: i32) -> Self {
1588        Self(value)
1589    }
1590    #[inline]
1591    pub const fn as_raw(self) -> i32 {
1592        self.0
1593    }
1594}
1595impl core::fmt::Debug for DebugReportObjectTypeEXT {
1596    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1597        match self.0 {
1598            0i32 => f.write_str("UNKNOWN"),
1599            1i32 => f.write_str("INSTANCE"),
1600            2i32 => f.write_str("PHYSICAL_DEVICE"),
1601            3i32 => f.write_str("DEVICE"),
1602            4i32 => f.write_str("QUEUE"),
1603            5i32 => f.write_str("SEMAPHORE"),
1604            6i32 => f.write_str("COMMAND_BUFFER"),
1605            7i32 => f.write_str("FENCE"),
1606            8i32 => f.write_str("DEVICE_MEMORY"),
1607            9i32 => f.write_str("BUFFER"),
1608            10i32 => f.write_str("IMAGE"),
1609            11i32 => f.write_str("EVENT"),
1610            12i32 => f.write_str("QUERY_POOL"),
1611            13i32 => f.write_str("BUFFER_VIEW"),
1612            14i32 => f.write_str("IMAGE_VIEW"),
1613            15i32 => f.write_str("SHADER_MODULE"),
1614            16i32 => f.write_str("PIPELINE_CACHE"),
1615            17i32 => f.write_str("PIPELINE_LAYOUT"),
1616            18i32 => f.write_str("RENDER_PASS"),
1617            19i32 => f.write_str("PIPELINE"),
1618            20i32 => f.write_str("DESCRIPTOR_SET_LAYOUT"),
1619            21i32 => f.write_str("SAMPLER"),
1620            22i32 => f.write_str("DESCRIPTOR_POOL"),
1621            23i32 => f.write_str("DESCRIPTOR_SET"),
1622            24i32 => f.write_str("FRAMEBUFFER"),
1623            25i32 => f.write_str("COMMAND_POOL"),
1624            26i32 => f.write_str("SURFACE_"),
1625            27i32 => f.write_str("SWAPCHAIN_"),
1626            28i32 => f.write_str("DEBUG_REPORT_CALLBACK_"),
1627            29i32 => f.write_str("DISPLAY_"),
1628            30i32 => f.write_str("DISPLAY_MODE_"),
1629            33i32 => f.write_str("VALIDATION_CACHE_"),
1630            1000156000i32 => f.write_str("SAMPLER_YCBCR_CONVERSION"),
1631            1000085000i32 => f.write_str("DESCRIPTOR_UPDATE_TEMPLATE"),
1632            1000029000i32 => f.write_str("CU_MODULE_"),
1633            1000029001i32 => f.write_str("CU_FUNCTION_"),
1634            1000150000i32 => f.write_str("ACCELERATION_STRUCTURE_"),
1635            1000307000i32 => f.write_str("CUDA_MODULE_"),
1636            1000307001i32 => f.write_str("CUDA_FUNCTION_"),
1637            1000366000i32 => f.write_str("BUFFER_COLLECTION_"),
1638            other => write!(f, "{}({})", stringify!(DebugReportObjectTypeEXT), other),
1639        }
1640    }
1641}
1642impl core::fmt::Display for DebugReportObjectTypeEXT {
1643    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1644        core::fmt::Debug::fmt(self, f)
1645    }
1646}
1647impl core::error::Error for DebugReportObjectTypeEXT {}
1648///[`VkDefaultVertexAttributeValueKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDefaultVertexAttributeValueKHR.html)
1649#[repr(transparent)]
1650#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1651#[doc(alias = "VkDefaultVertexAttributeValueKHR")]
1652pub struct DefaultVertexAttributeValueKHR(i32);
1653impl DefaultVertexAttributeValueKHR {
1654    pub const ZERO_ZERO_ZERO_ZERO: Self = Self(0i32);
1655    pub const ZERO_ZERO_ZERO_ONE: Self = Self(1i32);
1656    #[inline]
1657    pub const fn from_raw(value: i32) -> Self {
1658        Self(value)
1659    }
1660    #[inline]
1661    pub const fn as_raw(self) -> i32 {
1662        self.0
1663    }
1664}
1665impl core::fmt::Debug for DefaultVertexAttributeValueKHR {
1666    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1667        match self.0 {
1668            0i32 => f.write_str("ZERO_ZERO_ZERO_ZERO"),
1669            1i32 => f.write_str("ZERO_ZERO_ZERO_ONE"),
1670            other => {
1671                write!(f, "{}({})", stringify!(DefaultVertexAttributeValueKHR), other)
1672            }
1673        }
1674    }
1675}
1676impl core::fmt::Display for DefaultVertexAttributeValueKHR {
1677    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1678        core::fmt::Debug::fmt(self, f)
1679    }
1680}
1681impl core::error::Error for DefaultVertexAttributeValueKHR {}
1682///[`VkDepthBiasRepresentationEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthBiasRepresentationEXT.html)
1683#[repr(transparent)]
1684#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1685#[doc(alias = "VkDepthBiasRepresentationEXT")]
1686pub struct DepthBiasRepresentationEXT(i32);
1687impl DepthBiasRepresentationEXT {
1688    pub const LEAST_REPRESENTABLE_VALUE_FORMAT: Self = Self(0i32);
1689    pub const LEAST_REPRESENTABLE_VALUE_FORCE_UNORM: Self = Self(1i32);
1690    pub const FLOAT: Self = Self(2i32);
1691    #[inline]
1692    pub const fn from_raw(value: i32) -> Self {
1693        Self(value)
1694    }
1695    #[inline]
1696    pub const fn as_raw(self) -> i32 {
1697        self.0
1698    }
1699}
1700impl core::fmt::Debug for DepthBiasRepresentationEXT {
1701    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1702        match self.0 {
1703            0i32 => f.write_str("LEAST_REPRESENTABLE_VALUE_FORMAT"),
1704            1i32 => f.write_str("LEAST_REPRESENTABLE_VALUE_FORCE_UNORM"),
1705            2i32 => f.write_str("FLOAT"),
1706            other => write!(f, "{}({})", stringify!(DepthBiasRepresentationEXT), other),
1707        }
1708    }
1709}
1710impl core::fmt::Display for DepthBiasRepresentationEXT {
1711    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1712        core::fmt::Debug::fmt(self, f)
1713    }
1714}
1715impl core::error::Error for DepthBiasRepresentationEXT {}
1716///[`VkDepthClampModeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthClampModeEXT.html)
1717#[repr(transparent)]
1718#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1719#[doc(alias = "VkDepthClampModeEXT")]
1720pub struct DepthClampModeEXT(i32);
1721impl DepthClampModeEXT {
1722    pub const VIEWPORT_RANGE: Self = Self(0i32);
1723    pub const USER_DEFINED_RANGE: Self = Self(1i32);
1724    #[inline]
1725    pub const fn from_raw(value: i32) -> Self {
1726        Self(value)
1727    }
1728    #[inline]
1729    pub const fn as_raw(self) -> i32 {
1730        self.0
1731    }
1732}
1733impl core::fmt::Debug for DepthClampModeEXT {
1734    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1735        match self.0 {
1736            0i32 => f.write_str("VIEWPORT_RANGE"),
1737            1i32 => f.write_str("USER_DEFINED_RANGE"),
1738            other => write!(f, "{}({})", stringify!(DepthClampModeEXT), other),
1739        }
1740    }
1741}
1742impl core::fmt::Display for DepthClampModeEXT {
1743    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1744        core::fmt::Debug::fmt(self, f)
1745    }
1746}
1747impl core::error::Error for DepthClampModeEXT {}
1748///[`VkDescriptorMappingSourceEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceEXT.html)
1749#[repr(transparent)]
1750#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1751#[doc(alias = "VkDescriptorMappingSourceEXT")]
1752pub struct DescriptorMappingSourceEXT(i32);
1753impl DescriptorMappingSourceEXT {
1754    pub const HEAP_WITH_CONSTANT_OFFSET: Self = Self(0i32);
1755    pub const HEAP_WITH_PUSH_INDEX: Self = Self(1i32);
1756    pub const HEAP_WITH_INDIRECT_INDEX: Self = Self(2i32);
1757    pub const HEAP_WITH_INDIRECT_INDEX_ARRAY: Self = Self(3i32);
1758    pub const RESOURCE_HEAP_DATA: Self = Self(4i32);
1759    pub const PUSH_DATA: Self = Self(5i32);
1760    pub const PUSH_ADDRESS: Self = Self(6i32);
1761    pub const INDIRECT_ADDRESS: Self = Self(7i32);
1762    pub const HEAP_WITH_SHADER_RECORD_INDEX: Self = Self(8i32);
1763    pub const SHADER_RECORD_DATA: Self = Self(9i32);
1764    pub const SHADER_RECORD_ADDRESS: Self = Self(10i32);
1765    #[inline]
1766    pub const fn from_raw(value: i32) -> Self {
1767        Self(value)
1768    }
1769    #[inline]
1770    pub const fn as_raw(self) -> i32 {
1771        self.0
1772    }
1773}
1774impl core::fmt::Debug for DescriptorMappingSourceEXT {
1775    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1776        match self.0 {
1777            0i32 => f.write_str("HEAP_WITH_CONSTANT_OFFSET"),
1778            1i32 => f.write_str("HEAP_WITH_PUSH_INDEX"),
1779            2i32 => f.write_str("HEAP_WITH_INDIRECT_INDEX"),
1780            3i32 => f.write_str("HEAP_WITH_INDIRECT_INDEX_ARRAY"),
1781            4i32 => f.write_str("RESOURCE_HEAP_DATA"),
1782            5i32 => f.write_str("PUSH_DATA"),
1783            6i32 => f.write_str("PUSH_ADDRESS"),
1784            7i32 => f.write_str("INDIRECT_ADDRESS"),
1785            8i32 => f.write_str("HEAP_WITH_SHADER_RECORD_INDEX"),
1786            9i32 => f.write_str("SHADER_RECORD_DATA"),
1787            10i32 => f.write_str("SHADER_RECORD_ADDRESS"),
1788            other => write!(f, "{}({})", stringify!(DescriptorMappingSourceEXT), other),
1789        }
1790    }
1791}
1792impl core::fmt::Display for DescriptorMappingSourceEXT {
1793    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1794        core::fmt::Debug::fmt(self, f)
1795    }
1796}
1797impl core::error::Error for DescriptorMappingSourceEXT {}
1798///[`VkDescriptorType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorType.html)
1799#[repr(transparent)]
1800#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1801#[doc(alias = "VkDescriptorType")]
1802pub struct DescriptorType(i32);
1803impl DescriptorType {
1804    pub const SAMPLER: Self = Self(0i32);
1805    pub const COMBINED_IMAGE_SAMPLER: Self = Self(1i32);
1806    pub const SAMPLED_IMAGE: Self = Self(2i32);
1807    pub const STORAGE_IMAGE: Self = Self(3i32);
1808    pub const UNIFORM_TEXEL_BUFFER: Self = Self(4i32);
1809    pub const STORAGE_TEXEL_BUFFER: Self = Self(5i32);
1810    pub const UNIFORM_BUFFER: Self = Self(6i32);
1811    pub const STORAGE_BUFFER: Self = Self(7i32);
1812    pub const UNIFORM_BUFFER_DYNAMIC: Self = Self(8i32);
1813    pub const STORAGE_BUFFER_DYNAMIC: Self = Self(9i32);
1814    pub const INPUT_ATTACHMENT: Self = Self(10i32);
1815    pub const INLINE_UNIFORM_BLOCK: Self = Self(1000138000i32);
1816    pub const ACCELERATION_STRUCTURE: Self = Self(1000150000i32);
1817    pub const SAMPLE_WEIGHT_IMAGE: Self = Self(1000440000i32);
1818    pub const BLOCK_MATCH_IMAGE: Self = Self(1000440001i32);
1819    pub const TENSOR: Self = Self(1000460000i32);
1820    pub const PARTITIONED_ACCELERATION_STRUCTURE: Self = Self(1000570000i32);
1821    #[inline]
1822    pub const fn from_raw(value: i32) -> Self {
1823        Self(value)
1824    }
1825    #[inline]
1826    pub const fn as_raw(self) -> i32 {
1827        self.0
1828    }
1829}
1830impl core::fmt::Debug for DescriptorType {
1831    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1832        match self.0 {
1833            0i32 => f.write_str("SAMPLER"),
1834            1i32 => f.write_str("COMBINED_IMAGE_SAMPLER"),
1835            2i32 => f.write_str("SAMPLED_IMAGE"),
1836            3i32 => f.write_str("STORAGE_IMAGE"),
1837            4i32 => f.write_str("UNIFORM_TEXEL_BUFFER"),
1838            5i32 => f.write_str("STORAGE_TEXEL_BUFFER"),
1839            6i32 => f.write_str("UNIFORM_BUFFER"),
1840            7i32 => f.write_str("STORAGE_BUFFER"),
1841            8i32 => f.write_str("UNIFORM_BUFFER_DYNAMIC"),
1842            9i32 => f.write_str("STORAGE_BUFFER_DYNAMIC"),
1843            10i32 => f.write_str("INPUT_ATTACHMENT"),
1844            1000138000i32 => f.write_str("INLINE_UNIFORM_BLOCK"),
1845            1000150000i32 => f.write_str("ACCELERATION_STRUCTURE"),
1846            1000440000i32 => f.write_str("SAMPLE_WEIGHT_IMAGE"),
1847            1000440001i32 => f.write_str("BLOCK_MATCH_IMAGE"),
1848            1000460000i32 => f.write_str("TENSOR"),
1849            1000570000i32 => f.write_str("PARTITIONED_ACCELERATION_STRUCTURE"),
1850            other => write!(f, "{}({})", stringify!(DescriptorType), other),
1851        }
1852    }
1853}
1854impl core::fmt::Display for DescriptorType {
1855    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1856        core::fmt::Debug::fmt(self, f)
1857    }
1858}
1859impl core::error::Error for DescriptorType {}
1860///[`VkDescriptorUpdateTemplateType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateType.html)
1861#[repr(transparent)]
1862#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1863#[doc(alias = "VkDescriptorUpdateTemplateType")]
1864pub struct DescriptorUpdateTemplateType(i32);
1865impl DescriptorUpdateTemplateType {
1866    ///Create descriptor update template for descriptor set updates
1867    pub const DESCRIPTOR_SET: Self = Self(0i32);
1868    pub const PUSH_DESCRIPTORS: Self = Self(1i32);
1869    #[inline]
1870    pub const fn from_raw(value: i32) -> Self {
1871        Self(value)
1872    }
1873    #[inline]
1874    pub const fn as_raw(self) -> i32 {
1875        self.0
1876    }
1877}
1878impl core::fmt::Debug for DescriptorUpdateTemplateType {
1879    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1880        match self.0 {
1881            0i32 => f.write_str("DESCRIPTOR_SET"),
1882            1i32 => f.write_str("PUSH_DESCRIPTORS"),
1883            other => write!(f, "{}({})", stringify!(DescriptorUpdateTemplateType), other),
1884        }
1885    }
1886}
1887impl core::fmt::Display for DescriptorUpdateTemplateType {
1888    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1889        core::fmt::Debug::fmt(self, f)
1890    }
1891}
1892impl core::error::Error for DescriptorUpdateTemplateType {}
1893///[`VkDeviceAddressBindingTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingTypeEXT.html)
1894#[repr(transparent)]
1895#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1896#[doc(alias = "VkDeviceAddressBindingTypeEXT")]
1897pub struct DeviceAddressBindingTypeEXT(i32);
1898impl DeviceAddressBindingTypeEXT {
1899    pub const BIND: Self = Self(0i32);
1900    pub const UNBIND: Self = Self(1i32);
1901    #[inline]
1902    pub const fn from_raw(value: i32) -> Self {
1903        Self(value)
1904    }
1905    #[inline]
1906    pub const fn as_raw(self) -> i32 {
1907        self.0
1908    }
1909}
1910impl core::fmt::Debug for DeviceAddressBindingTypeEXT {
1911    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1912        match self.0 {
1913            0i32 => f.write_str("BIND"),
1914            1i32 => f.write_str("UNBIND"),
1915            other => write!(f, "{}({})", stringify!(DeviceAddressBindingTypeEXT), other),
1916        }
1917    }
1918}
1919impl core::fmt::Display for DeviceAddressBindingTypeEXT {
1920    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1921        core::fmt::Debug::fmt(self, f)
1922    }
1923}
1924impl core::error::Error for DeviceAddressBindingTypeEXT {}
1925///[`VkDeviceEventTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceEventTypeEXT.html)
1926#[repr(transparent)]
1927#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1928#[doc(alias = "VkDeviceEventTypeEXT")]
1929pub struct DeviceEventTypeEXT(i32);
1930impl DeviceEventTypeEXT {
1931    pub const DISPLAY_HOTPLUG: Self = Self(0i32);
1932    #[inline]
1933    pub const fn from_raw(value: i32) -> Self {
1934        Self(value)
1935    }
1936    #[inline]
1937    pub const fn as_raw(self) -> i32 {
1938        self.0
1939    }
1940}
1941impl core::fmt::Debug for DeviceEventTypeEXT {
1942    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1943        match self.0 {
1944            0i32 => f.write_str("DISPLAY_HOTPLUG"),
1945            other => write!(f, "{}({})", stringify!(DeviceEventTypeEXT), other),
1946        }
1947    }
1948}
1949impl core::fmt::Display for DeviceEventTypeEXT {
1950    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1951        core::fmt::Debug::fmt(self, f)
1952    }
1953}
1954impl core::error::Error for DeviceEventTypeEXT {}
1955///[`VkDeviceFaultAddressTypeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultAddressTypeKHR.html)
1956#[repr(transparent)]
1957#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
1958#[doc(alias = "VkDeviceFaultAddressTypeKHR")]
1959pub struct DeviceFaultAddressTypeKHR(i32);
1960impl DeviceFaultAddressTypeKHR {
1961    ///Currently unused
1962    pub const NONE: Self = Self(0i32);
1963    pub const READ_INVALID: Self = Self(1i32);
1964    pub const WRITE_INVALID: Self = Self(2i32);
1965    pub const EXECUTE_INVALID: Self = Self(3i32);
1966    pub const INSTRUCTION_POINTER_UNKNOWN: Self = Self(4i32);
1967    pub const INSTRUCTION_POINTER_INVALID: Self = Self(5i32);
1968    pub const INSTRUCTION_POINTER_FAULT: Self = Self(6i32);
1969    #[inline]
1970    pub const fn from_raw(value: i32) -> Self {
1971        Self(value)
1972    }
1973    #[inline]
1974    pub const fn as_raw(self) -> i32 {
1975        self.0
1976    }
1977}
1978impl core::fmt::Debug for DeviceFaultAddressTypeKHR {
1979    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1980        match self.0 {
1981            0i32 => f.write_str("NONE"),
1982            1i32 => f.write_str("READ_INVALID"),
1983            2i32 => f.write_str("WRITE_INVALID"),
1984            3i32 => f.write_str("EXECUTE_INVALID"),
1985            4i32 => f.write_str("INSTRUCTION_POINTER_UNKNOWN"),
1986            5i32 => f.write_str("INSTRUCTION_POINTER_INVALID"),
1987            6i32 => f.write_str("INSTRUCTION_POINTER_FAULT"),
1988            other => write!(f, "{}({})", stringify!(DeviceFaultAddressTypeKHR), other),
1989        }
1990    }
1991}
1992impl core::fmt::Display for DeviceFaultAddressTypeKHR {
1993    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1994        core::fmt::Debug::fmt(self, f)
1995    }
1996}
1997impl core::error::Error for DeviceFaultAddressTypeKHR {}
1998///[`VkDeviceFaultVendorBinaryHeaderVersionKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionKHR.html)
1999#[repr(transparent)]
2000#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2001#[doc(alias = "VkDeviceFaultVendorBinaryHeaderVersionKHR")]
2002pub struct DeviceFaultVendorBinaryHeaderVersionKHR(i32);
2003impl DeviceFaultVendorBinaryHeaderVersionKHR {
2004    pub const ONE: Self = Self(1i32);
2005    #[inline]
2006    pub const fn from_raw(value: i32) -> Self {
2007        Self(value)
2008    }
2009    #[inline]
2010    pub const fn as_raw(self) -> i32 {
2011        self.0
2012    }
2013}
2014impl core::fmt::Debug for DeviceFaultVendorBinaryHeaderVersionKHR {
2015    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2016        match self.0 {
2017            1i32 => f.write_str("ONE"),
2018            other => {
2019                write!(
2020                    f, "{}({})", stringify!(DeviceFaultVendorBinaryHeaderVersionKHR),
2021                    other
2022                )
2023            }
2024        }
2025    }
2026}
2027impl core::fmt::Display for DeviceFaultVendorBinaryHeaderVersionKHR {
2028    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2029        core::fmt::Debug::fmt(self, f)
2030    }
2031}
2032impl core::error::Error for DeviceFaultVendorBinaryHeaderVersionKHR {}
2033///[`VkDeviceMemoryReportEventTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryReportEventTypeEXT.html)
2034#[repr(transparent)]
2035#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2036#[doc(alias = "VkDeviceMemoryReportEventTypeEXT")]
2037pub struct DeviceMemoryReportEventTypeEXT(i32);
2038impl DeviceMemoryReportEventTypeEXT {
2039    pub const ALLOCATE: Self = Self(0i32);
2040    pub const FREE: Self = Self(1i32);
2041    pub const IMPORT: Self = Self(2i32);
2042    pub const UNIMPORT: Self = Self(3i32);
2043    pub const ALLOCATION_FAILED: Self = Self(4i32);
2044    #[inline]
2045    pub const fn from_raw(value: i32) -> Self {
2046        Self(value)
2047    }
2048    #[inline]
2049    pub const fn as_raw(self) -> i32 {
2050        self.0
2051    }
2052}
2053impl core::fmt::Debug for DeviceMemoryReportEventTypeEXT {
2054    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2055        match self.0 {
2056            0i32 => f.write_str("ALLOCATE"),
2057            1i32 => f.write_str("FREE"),
2058            2i32 => f.write_str("IMPORT"),
2059            3i32 => f.write_str("UNIMPORT"),
2060            4i32 => f.write_str("ALLOCATION_FAILED"),
2061            other => {
2062                write!(f, "{}({})", stringify!(DeviceMemoryReportEventTypeEXT), other)
2063            }
2064        }
2065    }
2066}
2067impl core::fmt::Display for DeviceMemoryReportEventTypeEXT {
2068    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2069        core::fmt::Debug::fmt(self, f)
2070    }
2071}
2072impl core::error::Error for DeviceMemoryReportEventTypeEXT {}
2073///[`VkDirectDriverLoadingModeLUNARG`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingModeLUNARG.html)
2074#[repr(transparent)]
2075#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2076#[doc(alias = "VkDirectDriverLoadingModeLUNARG")]
2077pub struct DirectDriverLoadingModeLUNARG(i32);
2078impl DirectDriverLoadingModeLUNARG {
2079    pub const EXCLUSIVE: Self = Self(0i32);
2080    pub const INCLUSIVE: Self = Self(1i32);
2081    #[inline]
2082    pub const fn from_raw(value: i32) -> Self {
2083        Self(value)
2084    }
2085    #[inline]
2086    pub const fn as_raw(self) -> i32 {
2087        self.0
2088    }
2089}
2090impl core::fmt::Debug for DirectDriverLoadingModeLUNARG {
2091    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2092        match self.0 {
2093            0i32 => f.write_str("EXCLUSIVE"),
2094            1i32 => f.write_str("INCLUSIVE"),
2095            other => {
2096                write!(f, "{}({})", stringify!(DirectDriverLoadingModeLUNARG), other)
2097            }
2098        }
2099    }
2100}
2101impl core::fmt::Display for DirectDriverLoadingModeLUNARG {
2102    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2103        core::fmt::Debug::fmt(self, f)
2104    }
2105}
2106impl core::error::Error for DirectDriverLoadingModeLUNARG {}
2107///[`VkDiscardRectangleModeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDiscardRectangleModeEXT.html)
2108#[repr(transparent)]
2109#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2110#[doc(alias = "VkDiscardRectangleModeEXT")]
2111pub struct DiscardRectangleModeEXT(i32);
2112impl DiscardRectangleModeEXT {
2113    pub const INCLUSIVE: Self = Self(0i32);
2114    pub const EXCLUSIVE: Self = Self(1i32);
2115    #[inline]
2116    pub const fn from_raw(value: i32) -> Self {
2117        Self(value)
2118    }
2119    #[inline]
2120    pub const fn as_raw(self) -> i32 {
2121        self.0
2122    }
2123}
2124impl core::fmt::Debug for DiscardRectangleModeEXT {
2125    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2126        match self.0 {
2127            0i32 => f.write_str("INCLUSIVE"),
2128            1i32 => f.write_str("EXCLUSIVE"),
2129            other => write!(f, "{}({})", stringify!(DiscardRectangleModeEXT), other),
2130        }
2131    }
2132}
2133impl core::fmt::Display for DiscardRectangleModeEXT {
2134    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2135        core::fmt::Debug::fmt(self, f)
2136    }
2137}
2138impl core::error::Error for DiscardRectangleModeEXT {}
2139///[`VkDisplacementMicromapFormatNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplacementMicromapFormatNV.html)
2140#[repr(transparent)]
2141#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2142#[doc(alias = "VkDisplacementMicromapFormatNV")]
2143pub struct DisplacementMicromapFormatNV(i32);
2144impl DisplacementMicromapFormatNV {
2145    pub const _64_TRIANGLES_64_BYTES: Self = Self(1i32);
2146    pub const _256_TRIANGLES_128_BYTES: Self = Self(2i32);
2147    pub const _1024_TRIANGLES_128_BYTES: Self = Self(3i32);
2148    #[inline]
2149    pub const fn from_raw(value: i32) -> Self {
2150        Self(value)
2151    }
2152    #[inline]
2153    pub const fn as_raw(self) -> i32 {
2154        self.0
2155    }
2156}
2157impl core::fmt::Debug for DisplacementMicromapFormatNV {
2158    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2159        match self.0 {
2160            1i32 => f.write_str("_64_TRIANGLES_64_BYTES"),
2161            2i32 => f.write_str("_256_TRIANGLES_128_BYTES"),
2162            3i32 => f.write_str("_1024_TRIANGLES_128_BYTES"),
2163            other => write!(f, "{}({})", stringify!(DisplacementMicromapFormatNV), other),
2164        }
2165    }
2166}
2167impl core::fmt::Display for DisplacementMicromapFormatNV {
2168    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2169        core::fmt::Debug::fmt(self, f)
2170    }
2171}
2172impl core::error::Error for DisplacementMicromapFormatNV {}
2173///[`VkDisplayEventTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayEventTypeEXT.html)
2174#[repr(transparent)]
2175#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2176#[doc(alias = "VkDisplayEventTypeEXT")]
2177pub struct DisplayEventTypeEXT(i32);
2178impl DisplayEventTypeEXT {
2179    pub const FIRST_PIXEL_OUT: Self = Self(0i32);
2180    #[inline]
2181    pub const fn from_raw(value: i32) -> Self {
2182        Self(value)
2183    }
2184    #[inline]
2185    pub const fn as_raw(self) -> i32 {
2186        self.0
2187    }
2188}
2189impl core::fmt::Debug for DisplayEventTypeEXT {
2190    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2191        match self.0 {
2192            0i32 => f.write_str("FIRST_PIXEL_OUT"),
2193            other => write!(f, "{}({})", stringify!(DisplayEventTypeEXT), other),
2194        }
2195    }
2196}
2197impl core::fmt::Display for DisplayEventTypeEXT {
2198    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2199        core::fmt::Debug::fmt(self, f)
2200    }
2201}
2202impl core::error::Error for DisplayEventTypeEXT {}
2203///[`VkDisplayPowerStateEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPowerStateEXT.html)
2204#[repr(transparent)]
2205#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2206#[doc(alias = "VkDisplayPowerStateEXT")]
2207pub struct DisplayPowerStateEXT(i32);
2208impl DisplayPowerStateEXT {
2209    pub const OFF: Self = Self(0i32);
2210    pub const SUSPEND: Self = Self(1i32);
2211    pub const ON: Self = Self(2i32);
2212    #[inline]
2213    pub const fn from_raw(value: i32) -> Self {
2214        Self(value)
2215    }
2216    #[inline]
2217    pub const fn as_raw(self) -> i32 {
2218        self.0
2219    }
2220}
2221impl core::fmt::Debug for DisplayPowerStateEXT {
2222    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2223        match self.0 {
2224            0i32 => f.write_str("OFF"),
2225            1i32 => f.write_str("SUSPEND"),
2226            2i32 => f.write_str("ON"),
2227            other => write!(f, "{}({})", stringify!(DisplayPowerStateEXT), other),
2228        }
2229    }
2230}
2231impl core::fmt::Display for DisplayPowerStateEXT {
2232    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2233        core::fmt::Debug::fmt(self, f)
2234    }
2235}
2236impl core::error::Error for DisplayPowerStateEXT {}
2237///[`VkDisplaySurfaceStereoTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceStereoTypeNV.html)
2238#[repr(transparent)]
2239#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2240#[doc(alias = "VkDisplaySurfaceStereoTypeNV")]
2241pub struct DisplaySurfaceStereoTypeNV(i32);
2242impl DisplaySurfaceStereoTypeNV {
2243    pub const NONE: Self = Self(0i32);
2244    pub const ONBOARD_DIN: Self = Self(1i32);
2245    pub const HDMI_3D: Self = Self(2i32);
2246    pub const INBAND_DISPLAYPORT: Self = Self(3i32);
2247    #[inline]
2248    pub const fn from_raw(value: i32) -> Self {
2249        Self(value)
2250    }
2251    #[inline]
2252    pub const fn as_raw(self) -> i32 {
2253        self.0
2254    }
2255}
2256impl core::fmt::Debug for DisplaySurfaceStereoTypeNV {
2257    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2258        match self.0 {
2259            0i32 => f.write_str("NONE"),
2260            1i32 => f.write_str("ONBOARD_DIN"),
2261            2i32 => f.write_str("HDMI_3D"),
2262            3i32 => f.write_str("INBAND_DISPLAYPORT"),
2263            other => write!(f, "{}({})", stringify!(DisplaySurfaceStereoTypeNV), other),
2264        }
2265    }
2266}
2267impl core::fmt::Display for DisplaySurfaceStereoTypeNV {
2268    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2269        core::fmt::Debug::fmt(self, f)
2270    }
2271}
2272impl core::error::Error for DisplaySurfaceStereoTypeNV {}
2273///[`VkDriverId`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDriverId.html)
2274#[repr(transparent)]
2275#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2276#[doc(alias = "VkDriverId")]
2277pub struct DriverId(i32);
2278impl DriverId {
2279    ///Advanced Micro Devices, Inc.
2280    pub const AMD_PROPRIETARY: Self = Self(1i32);
2281    ///Advanced Micro Devices, Inc.
2282    pub const AMD_OPEN_SOURCE: Self = Self(2i32);
2283    ///Mesa open source project
2284    pub const MESA_RADV: Self = Self(3i32);
2285    ///NVIDIA Corporation
2286    pub const NVIDIA_PROPRIETARY: Self = Self(4i32);
2287    ///Intel Corporation
2288    pub const INTEL_PROPRIETARY_WINDOWS: Self = Self(5i32);
2289    ///Intel Corporation
2290    pub const INTEL_OPEN_SOURCE: Self = Self(6i32);
2291    ///Imagination Technologies
2292    pub const IMAGINATION_PROPRIETARY: Self = Self(7i32);
2293    ///Qualcomm Technologies, Inc.
2294    pub const QUALCOMM_PROPRIETARY: Self = Self(8i32);
2295    ///Arm Limited
2296    pub const ARM_PROPRIETARY: Self = Self(9i32);
2297    ///Google LLC
2298    pub const GOOGLE_SWIFTSHADER: Self = Self(10i32);
2299    ///Google LLC
2300    pub const GGP_PROPRIETARY: Self = Self(11i32);
2301    ///Broadcom Inc.
2302    pub const BROADCOM_PROPRIETARY: Self = Self(12i32);
2303    ///Mesa
2304    pub const MESA_LLVMPIPE: Self = Self(13i32);
2305    ///MoltenVK
2306    pub const MOLTENVK: Self = Self(14i32);
2307    ///Core Avionics & Industrial Inc.
2308    pub const COREAVI_PROPRIETARY: Self = Self(15i32);
2309    ///Juice Technologies, Inc.
2310    pub const JUICE_PROPRIETARY: Self = Self(16i32);
2311    ///Verisilicon, Inc.
2312    pub const VERISILICON_PROPRIETARY: Self = Self(17i32);
2313    ///Mesa open source project
2314    pub const MESA_TURNIP: Self = Self(18i32);
2315    ///Mesa open source project
2316    pub const MESA_V3DV: Self = Self(19i32);
2317    ///Mesa open source project
2318    pub const MESA_PANVK: Self = Self(20i32);
2319    ///Samsung Electronics Co., Ltd.
2320    pub const SAMSUNG_PROPRIETARY: Self = Self(21i32);
2321    ///Mesa open source project
2322    pub const MESA_VENUS: Self = Self(22i32);
2323    ///Mesa open source project
2324    pub const MESA_DOZEN: Self = Self(23i32);
2325    ///Mesa open source project
2326    pub const MESA_NVK: Self = Self(24i32);
2327    ///Imagination Technologies
2328    pub const IMAGINATION_OPEN_SOURCE: Self = Self(25i32);
2329    ///Mesa open source project
2330    pub const MESA_HONEYKRISP: Self = Self(26i32);
2331    ///Vulkan SC Emulation on Vulkan
2332    pub const VULKAN_SC_EMULATION_ON_VULKAN: Self = Self(27i32);
2333    ///Mesa open source project
2334    pub const MESA_KOSMICKRISP: Self = Self(28i32);
2335    pub const INTEL_OPEN_SOURCE_: Self = Self::INTEL_OPEN_SOURCE;
2336    #[inline]
2337    pub const fn from_raw(value: i32) -> Self {
2338        Self(value)
2339    }
2340    #[inline]
2341    pub const fn as_raw(self) -> i32 {
2342        self.0
2343    }
2344}
2345impl core::fmt::Debug for DriverId {
2346    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2347        match self.0 {
2348            1i32 => f.write_str("AMD_PROPRIETARY"),
2349            2i32 => f.write_str("AMD_OPEN_SOURCE"),
2350            3i32 => f.write_str("MESA_RADV"),
2351            4i32 => f.write_str("NVIDIA_PROPRIETARY"),
2352            5i32 => f.write_str("INTEL_PROPRIETARY_WINDOWS"),
2353            6i32 => f.write_str("INTEL_OPEN_SOURCE"),
2354            7i32 => f.write_str("IMAGINATION_PROPRIETARY"),
2355            8i32 => f.write_str("QUALCOMM_PROPRIETARY"),
2356            9i32 => f.write_str("ARM_PROPRIETARY"),
2357            10i32 => f.write_str("GOOGLE_SWIFTSHADER"),
2358            11i32 => f.write_str("GGP_PROPRIETARY"),
2359            12i32 => f.write_str("BROADCOM_PROPRIETARY"),
2360            13i32 => f.write_str("MESA_LLVMPIPE"),
2361            14i32 => f.write_str("MOLTENVK"),
2362            15i32 => f.write_str("COREAVI_PROPRIETARY"),
2363            16i32 => f.write_str("JUICE_PROPRIETARY"),
2364            17i32 => f.write_str("VERISILICON_PROPRIETARY"),
2365            18i32 => f.write_str("MESA_TURNIP"),
2366            19i32 => f.write_str("MESA_V3DV"),
2367            20i32 => f.write_str("MESA_PANVK"),
2368            21i32 => f.write_str("SAMSUNG_PROPRIETARY"),
2369            22i32 => f.write_str("MESA_VENUS"),
2370            23i32 => f.write_str("MESA_DOZEN"),
2371            24i32 => f.write_str("MESA_NVK"),
2372            25i32 => f.write_str("IMAGINATION_OPEN_SOURCE"),
2373            26i32 => f.write_str("MESA_HONEYKRISP"),
2374            27i32 => f.write_str("VULKAN_SC_EMULATION_ON_VULKAN"),
2375            28i32 => f.write_str("MESA_KOSMICKRISP"),
2376            other => write!(f, "{}({})", stringify!(DriverId), other),
2377        }
2378    }
2379}
2380impl core::fmt::Display for DriverId {
2381    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2382        core::fmt::Debug::fmt(self, f)
2383    }
2384}
2385impl core::error::Error for DriverId {}
2386///[`VkDynamicState`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkDynamicState.html)
2387#[repr(transparent)]
2388#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2389#[doc(alias = "VkDynamicState")]
2390pub struct DynamicState(i32);
2391impl DynamicState {
2392    pub const VIEWPORT: Self = Self(0i32);
2393    pub const SCISSOR: Self = Self(1i32);
2394    pub const LINE_WIDTH: Self = Self(2i32);
2395    pub const DEPTH_BIAS: Self = Self(3i32);
2396    pub const BLEND_CONSTANTS: Self = Self(4i32);
2397    pub const DEPTH_BOUNDS: Self = Self(5i32);
2398    pub const STENCIL_COMPARE_MASK: Self = Self(6i32);
2399    pub const STENCIL_WRITE_MASK: Self = Self(7i32);
2400    pub const STENCIL_REFERENCE: Self = Self(8i32);
2401    pub const CULL_MODE: Self = Self(1000267000i32);
2402    pub const FRONT_FACE: Self = Self(1000267001i32);
2403    pub const PRIMITIVE_TOPOLOGY: Self = Self(1000267002i32);
2404    pub const VIEWPORT_WITH_COUNT: Self = Self(1000267003i32);
2405    pub const SCISSOR_WITH_COUNT: Self = Self(1000267004i32);
2406    pub const VERTEX_INPUT_BINDING_STRIDE: Self = Self(1000267005i32);
2407    pub const DEPTH_TEST_ENABLE: Self = Self(1000267006i32);
2408    pub const DEPTH_WRITE_ENABLE: Self = Self(1000267007i32);
2409    pub const DEPTH_COMPARE_OP: Self = Self(1000267008i32);
2410    pub const DEPTH_BOUNDS_TEST_ENABLE: Self = Self(1000267009i32);
2411    pub const STENCIL_TEST_ENABLE: Self = Self(1000267010i32);
2412    pub const STENCIL_OP: Self = Self(1000267011i32);
2413    pub const RASTERIZER_DISCARD_ENABLE: Self = Self(1000377001i32);
2414    pub const DEPTH_BIAS_ENABLE: Self = Self(1000377002i32);
2415    pub const PRIMITIVE_RESTART_ENABLE: Self = Self(1000377004i32);
2416    pub const LINE_STIPPLE: Self = Self(1000259000i32);
2417    pub const VIEWPORT_W_SCALING: Self = Self(1000087000i32);
2418    pub const DISCARD_RECTANGLE: Self = Self(1000099000i32);
2419    pub const DISCARD_RECTANGLE_ENABLE: Self = Self(1000099001i32);
2420    pub const DISCARD_RECTANGLE_MODE: Self = Self(1000099002i32);
2421    pub const SAMPLE_LOCATIONS: Self = Self(1000143000i32);
2422    pub const RAY_TRACING_PIPELINE_STACK_SIZE: Self = Self(1000347000i32);
2423    pub const VIEWPORT_SHADING_RATE_PALETTE: Self = Self(1000164004i32);
2424    pub const VIEWPORT_COARSE_SAMPLE_ORDER: Self = Self(1000164006i32);
2425    pub const EXCLUSIVE_SCISSOR_ENABLE: Self = Self(1000205000i32);
2426    pub const EXCLUSIVE_SCISSOR: Self = Self(1000205001i32);
2427    pub const FRAGMENT_SHADING_RATE: Self = Self(1000226000i32);
2428    pub const VERTEX_INPUT: Self = Self(1000352000i32);
2429    ///Not promoted to 1.3
2430    pub const PATCH_CONTROL_POINTS: Self = Self(1000377000i32);
2431    ///Not promoted to 1.3
2432    pub const LOGIC_OP: Self = Self(1000377003i32);
2433    pub const COLOR_WRITE_ENABLE: Self = Self(1000381000i32);
2434    pub const DEPTH_CLAMP_ENABLE: Self = Self(1000455003i32);
2435    pub const POLYGON_MODE: Self = Self(1000455004i32);
2436    pub const RASTERIZATION_SAMPLES: Self = Self(1000455005i32);
2437    pub const SAMPLE_MASK: Self = Self(1000455006i32);
2438    pub const ALPHA_TO_COVERAGE_ENABLE: Self = Self(1000455007i32);
2439    pub const ALPHA_TO_ONE_ENABLE: Self = Self(1000455008i32);
2440    pub const LOGIC_OP_ENABLE: Self = Self(1000455009i32);
2441    pub const COLOR_BLEND_ENABLE: Self = Self(1000455010i32);
2442    pub const COLOR_BLEND_EQUATION: Self = Self(1000455011i32);
2443    pub const COLOR_WRITE_MASK: Self = Self(1000455012i32);
2444    pub const TESSELLATION_DOMAIN_ORIGIN: Self = Self(1000455002i32);
2445    pub const RASTERIZATION_STREAM: Self = Self(1000455013i32);
2446    pub const CONSERVATIVE_RASTERIZATION_MODE: Self = Self(1000455014i32);
2447    pub const EXTRA_PRIMITIVE_OVERESTIMATION_SIZE: Self = Self(1000455015i32);
2448    pub const DEPTH_CLIP_ENABLE: Self = Self(1000455016i32);
2449    pub const SAMPLE_LOCATIONS_ENABLE: Self = Self(1000455017i32);
2450    pub const COLOR_BLEND_ADVANCED: Self = Self(1000455018i32);
2451    pub const PROVOKING_VERTEX_MODE: Self = Self(1000455019i32);
2452    pub const LINE_RASTERIZATION_MODE: Self = Self(1000455020i32);
2453    pub const LINE_STIPPLE_ENABLE: Self = Self(1000455021i32);
2454    pub const DEPTH_CLIP_NEGATIVE_ONE_TO_ONE: Self = Self(1000455022i32);
2455    pub const VIEWPORT_W_SCALING_ENABLE: Self = Self(1000455023i32);
2456    pub const VIEWPORT_SWIZZLE: Self = Self(1000455024i32);
2457    pub const COVERAGE_TO_COLOR_ENABLE: Self = Self(1000455025i32);
2458    pub const COVERAGE_TO_COLOR_LOCATION: Self = Self(1000455026i32);
2459    pub const COVERAGE_MODULATION_MODE: Self = Self(1000455027i32);
2460    pub const COVERAGE_MODULATION_TABLE_ENABLE: Self = Self(1000455028i32);
2461    pub const COVERAGE_MODULATION_TABLE: Self = Self(1000455029i32);
2462    pub const SHADING_RATE_IMAGE_ENABLE: Self = Self(1000455030i32);
2463    pub const REPRESENTATIVE_FRAGMENT_TEST_ENABLE: Self = Self(1000455031i32);
2464    pub const COVERAGE_REDUCTION_MODE: Self = Self(1000455032i32);
2465    pub const ATTACHMENT_FEEDBACK_LOOP_ENABLE: Self = Self(1000524000i32);
2466    pub const DEPTH_CLAMP_RANGE: Self = Self(1000582000i32);
2467    #[inline]
2468    pub const fn from_raw(value: i32) -> Self {
2469        Self(value)
2470    }
2471    #[inline]
2472    pub const fn as_raw(self) -> i32 {
2473        self.0
2474    }
2475}
2476impl core::fmt::Debug for DynamicState {
2477    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2478        match self.0 {
2479            0i32 => f.write_str("VIEWPORT"),
2480            1i32 => f.write_str("SCISSOR"),
2481            2i32 => f.write_str("LINE_WIDTH"),
2482            3i32 => f.write_str("DEPTH_BIAS"),
2483            4i32 => f.write_str("BLEND_CONSTANTS"),
2484            5i32 => f.write_str("DEPTH_BOUNDS"),
2485            6i32 => f.write_str("STENCIL_COMPARE_MASK"),
2486            7i32 => f.write_str("STENCIL_WRITE_MASK"),
2487            8i32 => f.write_str("STENCIL_REFERENCE"),
2488            1000267000i32 => f.write_str("CULL_MODE"),
2489            1000267001i32 => f.write_str("FRONT_FACE"),
2490            1000267002i32 => f.write_str("PRIMITIVE_TOPOLOGY"),
2491            1000267003i32 => f.write_str("VIEWPORT_WITH_COUNT"),
2492            1000267004i32 => f.write_str("SCISSOR_WITH_COUNT"),
2493            1000267005i32 => f.write_str("VERTEX_INPUT_BINDING_STRIDE"),
2494            1000267006i32 => f.write_str("DEPTH_TEST_ENABLE"),
2495            1000267007i32 => f.write_str("DEPTH_WRITE_ENABLE"),
2496            1000267008i32 => f.write_str("DEPTH_COMPARE_OP"),
2497            1000267009i32 => f.write_str("DEPTH_BOUNDS_TEST_ENABLE"),
2498            1000267010i32 => f.write_str("STENCIL_TEST_ENABLE"),
2499            1000267011i32 => f.write_str("STENCIL_OP"),
2500            1000377001i32 => f.write_str("RASTERIZER_DISCARD_ENABLE"),
2501            1000377002i32 => f.write_str("DEPTH_BIAS_ENABLE"),
2502            1000377004i32 => f.write_str("PRIMITIVE_RESTART_ENABLE"),
2503            1000259000i32 => f.write_str("LINE_STIPPLE"),
2504            1000087000i32 => f.write_str("VIEWPORT_W_SCALING"),
2505            1000099000i32 => f.write_str("DISCARD_RECTANGLE"),
2506            1000099001i32 => f.write_str("DISCARD_RECTANGLE_ENABLE"),
2507            1000099002i32 => f.write_str("DISCARD_RECTANGLE_MODE"),
2508            1000143000i32 => f.write_str("SAMPLE_LOCATIONS"),
2509            1000347000i32 => f.write_str("RAY_TRACING_PIPELINE_STACK_SIZE"),
2510            1000164004i32 => f.write_str("VIEWPORT_SHADING_RATE_PALETTE"),
2511            1000164006i32 => f.write_str("VIEWPORT_COARSE_SAMPLE_ORDER"),
2512            1000205000i32 => f.write_str("EXCLUSIVE_SCISSOR_ENABLE"),
2513            1000205001i32 => f.write_str("EXCLUSIVE_SCISSOR"),
2514            1000226000i32 => f.write_str("FRAGMENT_SHADING_RATE"),
2515            1000352000i32 => f.write_str("VERTEX_INPUT"),
2516            1000377000i32 => f.write_str("PATCH_CONTROL_POINTS"),
2517            1000377003i32 => f.write_str("LOGIC_OP"),
2518            1000381000i32 => f.write_str("COLOR_WRITE_ENABLE"),
2519            1000455003i32 => f.write_str("DEPTH_CLAMP_ENABLE"),
2520            1000455004i32 => f.write_str("POLYGON_MODE"),
2521            1000455005i32 => f.write_str("RASTERIZATION_SAMPLES"),
2522            1000455006i32 => f.write_str("SAMPLE_MASK"),
2523            1000455007i32 => f.write_str("ALPHA_TO_COVERAGE_ENABLE"),
2524            1000455008i32 => f.write_str("ALPHA_TO_ONE_ENABLE"),
2525            1000455009i32 => f.write_str("LOGIC_OP_ENABLE"),
2526            1000455010i32 => f.write_str("COLOR_BLEND_ENABLE"),
2527            1000455011i32 => f.write_str("COLOR_BLEND_EQUATION"),
2528            1000455012i32 => f.write_str("COLOR_WRITE_MASK"),
2529            1000455002i32 => f.write_str("TESSELLATION_DOMAIN_ORIGIN"),
2530            1000455013i32 => f.write_str("RASTERIZATION_STREAM"),
2531            1000455014i32 => f.write_str("CONSERVATIVE_RASTERIZATION_MODE"),
2532            1000455015i32 => f.write_str("EXTRA_PRIMITIVE_OVERESTIMATION_SIZE"),
2533            1000455016i32 => f.write_str("DEPTH_CLIP_ENABLE"),
2534            1000455017i32 => f.write_str("SAMPLE_LOCATIONS_ENABLE"),
2535            1000455018i32 => f.write_str("COLOR_BLEND_ADVANCED"),
2536            1000455019i32 => f.write_str("PROVOKING_VERTEX_MODE"),
2537            1000455020i32 => f.write_str("LINE_RASTERIZATION_MODE"),
2538            1000455021i32 => f.write_str("LINE_STIPPLE_ENABLE"),
2539            1000455022i32 => f.write_str("DEPTH_CLIP_NEGATIVE_ONE_TO_ONE"),
2540            1000455023i32 => f.write_str("VIEWPORT_W_SCALING_ENABLE"),
2541            1000455024i32 => f.write_str("VIEWPORT_SWIZZLE"),
2542            1000455025i32 => f.write_str("COVERAGE_TO_COLOR_ENABLE"),
2543            1000455026i32 => f.write_str("COVERAGE_TO_COLOR_LOCATION"),
2544            1000455027i32 => f.write_str("COVERAGE_MODULATION_MODE"),
2545            1000455028i32 => f.write_str("COVERAGE_MODULATION_TABLE_ENABLE"),
2546            1000455029i32 => f.write_str("COVERAGE_MODULATION_TABLE"),
2547            1000455030i32 => f.write_str("SHADING_RATE_IMAGE_ENABLE"),
2548            1000455031i32 => f.write_str("REPRESENTATIVE_FRAGMENT_TEST_ENABLE"),
2549            1000455032i32 => f.write_str("COVERAGE_REDUCTION_MODE"),
2550            1000524000i32 => f.write_str("ATTACHMENT_FEEDBACK_LOOP_ENABLE"),
2551            1000582000i32 => f.write_str("DEPTH_CLAMP_RANGE"),
2552            other => write!(f, "{}({})", stringify!(DynamicState), other),
2553        }
2554    }
2555}
2556impl core::fmt::Display for DynamicState {
2557    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2558        core::fmt::Debug::fmt(self, f)
2559    }
2560}
2561impl core::error::Error for DynamicState {}
2562///[`VkFaultLevel`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFaultLevel.html)
2563#[repr(transparent)]
2564#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2565#[doc(alias = "VkFaultLevel")]
2566pub struct FaultLevel(i32);
2567impl FaultLevel {
2568    pub const UNASSIGNED: Self = Self(0i32);
2569    pub const CRITICAL: Self = Self(1i32);
2570    pub const RECOVERABLE: Self = Self(2i32);
2571    pub const WARNING: Self = Self(3i32);
2572    #[inline]
2573    pub const fn from_raw(value: i32) -> Self {
2574        Self(value)
2575    }
2576    #[inline]
2577    pub const fn as_raw(self) -> i32 {
2578        self.0
2579    }
2580}
2581impl core::fmt::Debug for FaultLevel {
2582    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2583        match self.0 {
2584            0i32 => f.write_str("UNASSIGNED"),
2585            1i32 => f.write_str("CRITICAL"),
2586            2i32 => f.write_str("RECOVERABLE"),
2587            3i32 => f.write_str("WARNING"),
2588            other => write!(f, "{}({})", stringify!(FaultLevel), other),
2589        }
2590    }
2591}
2592impl core::fmt::Display for FaultLevel {
2593    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2594        core::fmt::Debug::fmt(self, f)
2595    }
2596}
2597impl core::error::Error for FaultLevel {}
2598///[`VkFaultQueryBehavior`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFaultQueryBehavior.html)
2599#[repr(transparent)]
2600#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2601#[doc(alias = "VkFaultQueryBehavior")]
2602pub struct FaultQueryBehavior(i32);
2603impl FaultQueryBehavior {
2604    pub const GET_AND_CLEAR_ALL_FAULTS: Self = Self(0i32);
2605    #[inline]
2606    pub const fn from_raw(value: i32) -> Self {
2607        Self(value)
2608    }
2609    #[inline]
2610    pub const fn as_raw(self) -> i32 {
2611        self.0
2612    }
2613}
2614impl core::fmt::Debug for FaultQueryBehavior {
2615    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2616        match self.0 {
2617            0i32 => f.write_str("GET_AND_CLEAR_ALL_FAULTS"),
2618            other => write!(f, "{}({})", stringify!(FaultQueryBehavior), other),
2619        }
2620    }
2621}
2622impl core::fmt::Display for FaultQueryBehavior {
2623    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2624        core::fmt::Debug::fmt(self, f)
2625    }
2626}
2627impl core::error::Error for FaultQueryBehavior {}
2628///[`VkFaultType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFaultType.html)
2629#[repr(transparent)]
2630#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2631#[doc(alias = "VkFaultType")]
2632pub struct FaultType(i32);
2633impl FaultType {
2634    pub const INVALID: Self = Self(0i32);
2635    pub const UNASSIGNED: Self = Self(1i32);
2636    pub const IMPLEMENTATION: Self = Self(2i32);
2637    pub const SYSTEM: Self = Self(3i32);
2638    pub const PHYSICAL_DEVICE: Self = Self(4i32);
2639    pub const COMMAND_BUFFER_FULL: Self = Self(5i32);
2640    pub const INVALID_API_USAGE: Self = Self(6i32);
2641    #[inline]
2642    pub const fn from_raw(value: i32) -> Self {
2643        Self(value)
2644    }
2645    #[inline]
2646    pub const fn as_raw(self) -> i32 {
2647        self.0
2648    }
2649}
2650impl core::fmt::Debug for FaultType {
2651    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2652        match self.0 {
2653            0i32 => f.write_str("INVALID"),
2654            1i32 => f.write_str("UNASSIGNED"),
2655            2i32 => f.write_str("IMPLEMENTATION"),
2656            3i32 => f.write_str("SYSTEM"),
2657            4i32 => f.write_str("PHYSICAL_DEVICE"),
2658            5i32 => f.write_str("COMMAND_BUFFER_FULL"),
2659            6i32 => f.write_str("INVALID_API_USAGE"),
2660            other => write!(f, "{}({})", stringify!(FaultType), other),
2661        }
2662    }
2663}
2664impl core::fmt::Display for FaultType {
2665    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2666        core::fmt::Debug::fmt(self, f)
2667    }
2668}
2669impl core::error::Error for FaultType {}
2670///[`VkFilter`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFilter.html)
2671#[repr(transparent)]
2672#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2673#[doc(alias = "VkFilter")]
2674pub struct Filter(i32);
2675impl Filter {
2676    pub const NEAREST: Self = Self(0i32);
2677    pub const LINEAR: Self = Self(1i32);
2678    #[inline]
2679    pub const fn from_raw(value: i32) -> Self {
2680        Self(value)
2681    }
2682    #[inline]
2683    pub const fn as_raw(self) -> i32 {
2684        self.0
2685    }
2686}
2687impl core::fmt::Debug for Filter {
2688    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2689        match self.0 {
2690            0i32 => f.write_str("NEAREST"),
2691            1i32 => f.write_str("LINEAR"),
2692            other => write!(f, "{}({})", stringify!(Filter), other),
2693        }
2694    }
2695}
2696impl core::fmt::Display for Filter {
2697    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
2698        core::fmt::Debug::fmt(self, f)
2699    }
2700}
2701impl core::error::Error for Filter {}
2702///[`VkFormat`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormat.html)
2703#[repr(transparent)]
2704#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
2705#[doc(alias = "VkFormat")]
2706pub struct Format(i32);
2707impl Format {
2708    pub const UNDEFINED: Self = Self(0i32);
2709    pub const R4G4_UNORM_PACK8: Self = Self(1i32);
2710    pub const R4G4B4A4_UNORM_PACK16: Self = Self(2i32);
2711    pub const B4G4R4A4_UNORM_PACK16: Self = Self(3i32);
2712    pub const R5G6B5_UNORM_PACK16: Self = Self(4i32);
2713    pub const B5G6R5_UNORM_PACK16: Self = Self(5i32);
2714    pub const R5G5B5A1_UNORM_PACK16: Self = Self(6i32);
2715    pub const B5G5R5A1_UNORM_PACK16: Self = Self(7i32);
2716    pub const A1R5G5B5_UNORM_PACK16: Self = Self(8i32);
2717    pub const R8_UNORM: Self = Self(9i32);
2718    pub const R8_SNORM: Self = Self(10i32);
2719    pub const R8_USCALED: Self = Self(11i32);
2720    pub const R8_SSCALED: Self = Self(12i32);
2721    pub const R8_UINT: Self = Self(13i32);
2722    pub const R8_SINT: Self = Self(14i32);
2723    pub const R8_SRGB: Self = Self(15i32);
2724    pub const R8G8_UNORM: Self = Self(16i32);
2725    pub const R8G8_SNORM: Self = Self(17i32);
2726    pub const R8G8_USCALED: Self = Self(18i32);
2727    pub const R8G8_SSCALED: Self = Self(19i32);
2728    pub const R8G8_UINT: Self = Self(20i32);
2729    pub const R8G8_SINT: Self = Self(21i32);
2730    pub const R8G8_SRGB: Self = Self(22i32);
2731    pub const R8G8B8_UNORM: Self = Self(23i32);
2732    pub const R8G8B8_SNORM: Self = Self(24i32);
2733    pub const R8G8B8_USCALED: Self = Self(25i32);
2734    pub const R8G8B8_SSCALED: Self = Self(26i32);
2735    pub const R8G8B8_UINT: Self = Self(27i32);
2736    pub const R8G8B8_SINT: Self = Self(28i32);
2737    pub const R8G8B8_SRGB: Self = Self(29i32);
2738    pub const B8G8R8_UNORM: Self = Self(30i32);
2739    pub const B8G8R8_SNORM: Self = Self(31i32);
2740    pub const B8G8R8_USCALED: Self = Self(32i32);
2741    pub const B8G8R8_SSCALED: Self = Self(33i32);
2742    pub const B8G8R8_UINT: Self = Self(34i32);
2743    pub const B8G8R8_SINT: Self = Self(35i32);
2744    pub const B8G8R8_SRGB: Self = Self(36i32);
2745    pub const R8G8B8A8_UNORM: Self = Self(37i32);
2746    pub const R8G8B8A8_SNORM: Self = Self(38i32);
2747    pub const R8G8B8A8_USCALED: Self = Self(39i32);
2748    pub const R8G8B8A8_SSCALED: Self = Self(40i32);
2749    pub const R8G8B8A8_UINT: Self = Self(41i32);
2750    pub const R8G8B8A8_SINT: Self = Self(42i32);
2751    pub const R8G8B8A8_SRGB: Self = Self(43i32);
2752    pub const B8G8R8A8_UNORM: Self = Self(44i32);
2753    pub const B8G8R8A8_SNORM: Self = Self(45i32);
2754    pub const B8G8R8A8_USCALED: Self = Self(46i32);
2755    pub const B8G8R8A8_SSCALED: Self = Self(47i32);
2756    pub const B8G8R8A8_UINT: Self = Self(48i32);
2757    pub const B8G8R8A8_SINT: Self = Self(49i32);
2758    pub const B8G8R8A8_SRGB: Self = Self(50i32);
2759    pub const A8B8G8R8_UNORM_PACK32: Self = Self(51i32);
2760    pub const A8B8G8R8_SNORM_PACK32: Self = Self(52i32);
2761    pub const A8B8G8R8_USCALED_PACK32: Self = Self(53i32);
2762    pub const A8B8G8R8_SSCALED_PACK32: Self = Self(54i32);
2763    pub const A8B8G8R8_UINT_PACK32: Self = Self(55i32);
2764    pub const A8B8G8R8_SINT_PACK32: Self = Self(56i32);
2765    pub const A8B8G8R8_SRGB_PACK32: Self = Self(57i32);
2766    pub const A2R10G10B10_UNORM_PACK32: Self = Self(58i32);
2767    pub const A2R10G10B10_SNORM_PACK32: Self = Self(59i32);
2768    pub const A2R10G10B10_USCALED_PACK32: Self = Self(60i32);
2769    pub const A2R10G10B10_SSCALED_PACK32: Self = Self(61i32);
2770    pub const A2R10G10B10_UINT_PACK32: Self = Self(62i32);
2771    pub const A2R10G10B10_SINT_PACK32: Self = Self(63i32);
2772    pub const A2B10G10R10_UNORM_PACK32: Self = Self(64i32);
2773    pub const A2B10G10R10_SNORM_PACK32: Self = Self(65i32);
2774    pub const A2B10G10R10_USCALED_PACK32: Self = Self(66i32);
2775    pub const A2B10G10R10_SSCALED_PACK32: Self = Self(67i32);
2776    pub const A2B10G10R10_UINT_PACK32: Self = Self(68i32);
2777    pub const A2B10G10R10_SINT_PACK32: Self = Self(69i32);
2778    pub const R16_UNORM: Self = Self(70i32);
2779    pub const R16_SNORM: Self = Self(71i32);
2780    pub const R16_USCALED: Self = Self(72i32);
2781    pub const R16_SSCALED: Self = Self(73i32);
2782    pub const R16_UINT: Self = Self(74i32);
2783    pub const R16_SINT: Self = Self(75i32);
2784    pub const R16_SFLOAT: Self = Self(76i32);
2785    pub const R16G16_UNORM: Self = Self(77i32);
2786    pub const R16G16_SNORM: Self = Self(78i32);
2787    pub const R16G16_USCALED: Self = Self(79i32);
2788    pub const R16G16_SSCALED: Self = Self(80i32);
2789    pub const R16G16_UINT: Self = Self(81i32);
2790    pub const R16G16_SINT: Self = Self(82i32);
2791    pub const R16G16_SFLOAT: Self = Self(83i32);
2792    pub const R16G16B16_UNORM: Self = Self(84i32);
2793    pub const R16G16B16_SNORM: Self = Self(85i32);
2794    pub const R16G16B16_USCALED: Self = Self(86i32);
2795    pub const R16G16B16_SSCALED: Self = Self(87i32);
2796    pub const R16G16B16_UINT: Self = Self(88i32);
2797    pub const R16G16B16_SINT: Self = Self(89i32);
2798    pub const R16G16B16_SFLOAT: Self = Self(90i32);
2799    pub const R16G16B16A16_UNORM: Self = Self(91i32);
2800    pub const R16G16B16A16_SNORM: Self = Self(92i32);
2801    pub const R16G16B16A16_USCALED: Self = Self(93i32);
2802    pub const R16G16B16A16_SSCALED: Self = Self(94i32);
2803    pub const R16G16B16A16_UINT: Self = Self(95i32);
2804    pub const R16G16B16A16_SINT: Self = Self(96i32);
2805    pub const R16G16B16A16_SFLOAT: Self = Self(97i32);
2806    pub const R32_UINT: Self = Self(98i32);
2807    pub const R32_SINT: Self = Self(99i32);
2808    pub const R32_SFLOAT: Self = Self(100i32);
2809    pub const R32G32_UINT: Self = Self(101i32);
2810    pub const R32G32_SINT: Self = Self(102i32);
2811    pub const R32G32_SFLOAT: Self = Self(103i32);
2812    pub const R32G32B32_UINT: Self = Self(104i32);
2813    pub const R32G32B32_SINT: Self = Self(105i32);
2814    pub const R32G32B32_SFLOAT: Self = Self(106i32);
2815    pub const R32G32B32A32_UINT: Self = Self(107i32);
2816    pub const R32G32B32A32_SINT: Self = Self(108i32);
2817    pub const R32G32B32A32_SFLOAT: Self = Self(109i32);
2818    pub const R64_UINT: Self = Self(110i32);
2819    pub const R64_SINT: Self = Self(111i32);
2820    pub const R64_SFLOAT: Self = Self(112i32);
2821    pub const R64G64_UINT: Self = Self(113i32);
2822    pub const R64G64_SINT: Self = Self(114i32);
2823    pub const R64G64_SFLOAT: Self = Self(115i32);
2824    pub const R64G64B64_UINT: Self = Self(116i32);
2825    pub const R64G64B64_SINT: Self = Self(117i32);
2826    pub const R64G64B64_SFLOAT: Self = Self(118i32);
2827    pub const R64G64B64A64_UINT: Self = Self(119i32);
2828    pub const R64G64B64A64_SINT: Self = Self(120i32);
2829    pub const R64G64B64A64_SFLOAT: Self = Self(121i32);
2830    pub const B10G11R11_UFLOAT_PACK32: Self = Self(122i32);
2831    pub const E5B9G9R9_UFLOAT_PACK32: Self = Self(123i32);
2832    pub const D16_UNORM: Self = Self(124i32);
2833    pub const X8_D24_UNORM_PACK32: Self = Self(125i32);
2834    pub const D32_SFLOAT: Self = Self(126i32);
2835    pub const S8_UINT: Self = Self(127i32);
2836    pub const D16_UNORM_S8_UINT: Self = Self(128i32);
2837    pub const D24_UNORM_S8_UINT: Self = Self(129i32);
2838    pub const D32_SFLOAT_S8_UINT: Self = Self(130i32);
2839    pub const BC1_RGB_UNORM_BLOCK: Self = Self(131i32);
2840    pub const BC1_RGB_SRGB_BLOCK: Self = Self(132i32);
2841    pub const BC1_RGBA_UNORM_BLOCK: Self = Self(133i32);
2842    pub const BC1_RGBA_SRGB_BLOCK: Self = Self(134i32);
2843    pub const BC2_UNORM_BLOCK: Self = Self(135i32);
2844    pub const BC2_SRGB_BLOCK: Self = Self(136i32);
2845    pub const BC3_UNORM_BLOCK: Self = Self(137i32);
2846    pub const BC3_SRGB_BLOCK: Self = Self(138i32);
2847    pub const BC4_UNORM_BLOCK: Self = Self(139i32);
2848    pub const BC4_SNORM_BLOCK: Self = Self(140i32);
2849    pub const BC5_UNORM_BLOCK: Self = Self(141i32);
2850    pub const BC5_SNORM_BLOCK: Self = Self(142i32);
2851    pub const BC6H_UFLOAT_BLOCK: Self = Self(143i32);
2852    pub const BC6H_SFLOAT_BLOCK: Self = Self(144i32);
2853    pub const BC7_UNORM_BLOCK: Self = Self(145i32);
2854    pub const BC7_SRGB_BLOCK: Self = Self(146i32);
2855    pub const ETC2_R8G8B8_UNORM_BLOCK: Self = Self(147i32);
2856    pub const ETC2_R8G8B8_SRGB_BLOCK: Self = Self(148i32);
2857    pub const ETC2_R8G8B8A1_UNORM_BLOCK: Self = Self(149i32);
2858    pub const ETC2_R8G8B8A1_SRGB_BLOCK: Self = Self(150i32);
2859    pub const ETC2_R8G8B8A8_UNORM_BLOCK: Self = Self(151i32);
2860    pub const ETC2_R8G8B8A8_SRGB_BLOCK: Self = Self(152i32);
2861    pub const EAC_R11_UNORM_BLOCK: Self = Self(153i32);
2862    pub const EAC_R11_SNORM_BLOCK: Self = Self(154i32);
2863    pub const EAC_R11G11_UNORM_BLOCK: Self = Self(155i32);
2864    pub const EAC_R11G11_SNORM_BLOCK: Self = Self(156i32);
2865    pub const ASTC_4x4_UNORM_BLOCK: Self = Self(157i32);
2866    pub const ASTC_4x4_SRGB_BLOCK: Self = Self(158i32);
2867    pub const ASTC_5x4_UNORM_BLOCK: Self = Self(159i32);
2868    pub const ASTC_5x4_SRGB_BLOCK: Self = Self(160i32);
2869    pub const ASTC_5x5_UNORM_BLOCK: Self = Self(161i32);
2870    pub const ASTC_5x5_SRGB_BLOCK: Self = Self(162i32);
2871    pub const ASTC_6x5_UNORM_BLOCK: Self = Self(163i32);
2872    pub const ASTC_6x5_SRGB_BLOCK: Self = Self(164i32);
2873    pub const ASTC_6x6_UNORM_BLOCK: Self = Self(165i32);
2874    pub const ASTC_6x6_SRGB_BLOCK: Self = Self(166i32);
2875    pub const ASTC_8x5_UNORM_BLOCK: Self = Self(167i32);
2876    pub const ASTC_8x5_SRGB_BLOCK: Self = Self(168i32);
2877    pub const ASTC_8x6_UNORM_BLOCK: Self = Self(169i32);
2878    pub const ASTC_8x6_SRGB_BLOCK: Self = Self(170i32);
2879    pub const ASTC_8x8_UNORM_BLOCK: Self = Self(171i32);
2880    pub const ASTC_8x8_SRGB_BLOCK: Self = Self(172i32);
2881    pub const ASTC_10x5_UNORM_BLOCK: Self = Self(173i32);
2882    pub const ASTC_10x5_SRGB_BLOCK: Self = Self(174i32);
2883    pub const ASTC_10x6_UNORM_BLOCK: Self = Self(175i32);
2884    pub const ASTC_10x6_SRGB_BLOCK: Self = Self(176i32);
2885    pub const ASTC_10x8_UNORM_BLOCK: Self = Self(177i32);
2886    pub const ASTC_10x8_SRGB_BLOCK: Self = Self(178i32);
2887    pub const ASTC_10x10_UNORM_BLOCK: Self = Self(179i32);
2888    pub const ASTC_10x10_SRGB_BLOCK: Self = Self(180i32);
2889    pub const ASTC_12x10_UNORM_BLOCK: Self = Self(181i32);
2890    pub const ASTC_12x10_SRGB_BLOCK: Self = Self(182i32);
2891    pub const ASTC_12x12_UNORM_BLOCK: Self = Self(183i32);
2892    pub const ASTC_12x12_SRGB_BLOCK: Self = Self(184i32);
2893    pub const G8B8G8R8_422_UNORM: Self = Self(1000156000i32);
2894    pub const B8G8R8G8_422_UNORM: Self = Self(1000156001i32);
2895    pub const G8_B8_R8_3PLANE_420_UNORM: Self = Self(1000156002i32);
2896    pub const G8_B8R8_2PLANE_420_UNORM: Self = Self(1000156003i32);
2897    pub const G8_B8_R8_3PLANE_422_UNORM: Self = Self(1000156004i32);
2898    pub const G8_B8R8_2PLANE_422_UNORM: Self = Self(1000156005i32);
2899    pub const G8_B8_R8_3PLANE_444_UNORM: Self = Self(1000156006i32);
2900    pub const R10X6_UNORM_PACK16: Self = Self(1000156007i32);
2901    pub const R10X6G10X6_UNORM_2PACK16: Self = Self(1000156008i32);
2902    pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16: Self = Self(1000156009i32);
2903    pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: Self = Self(1000156010i32);
2904    pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: Self = Self(1000156011i32);
2905    pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: Self = Self(1000156012i32);
2906    pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: Self = Self(1000156013i32);
2907    pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: Self = Self(1000156014i32);
2908    pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: Self = Self(1000156015i32);
2909    pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: Self = Self(1000156016i32);
2910    pub const R12X4_UNORM_PACK16: Self = Self(1000156017i32);
2911    pub const R12X4G12X4_UNORM_2PACK16: Self = Self(1000156018i32);
2912    pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16: Self = Self(1000156019i32);
2913    pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: Self = Self(1000156020i32);
2914    pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: Self = Self(1000156021i32);
2915    pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: Self = Self(1000156022i32);
2916    pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: Self = Self(1000156023i32);
2917    pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: Self = Self(1000156024i32);
2918    pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: Self = Self(1000156025i32);
2919    pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: Self = Self(1000156026i32);
2920    pub const G16B16G16R16_422_UNORM: Self = Self(1000156027i32);
2921    pub const B16G16R16G16_422_UNORM: Self = Self(1000156028i32);
2922    pub const G16_B16_R16_3PLANE_420_UNORM: Self = Self(1000156029i32);
2923    pub const G16_B16R16_2PLANE_420_UNORM: Self = Self(1000156030i32);
2924    pub const G16_B16_R16_3PLANE_422_UNORM: Self = Self(1000156031i32);
2925    pub const G16_B16R16_2PLANE_422_UNORM: Self = Self(1000156032i32);
2926    pub const G16_B16_R16_3PLANE_444_UNORM: Self = Self(1000156033i32);
2927    pub const G8_B8R8_2PLANE_444_UNORM: Self = Self(1000330000i32);
2928    pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: Self = Self(1000330001i32);
2929    pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: Self = Self(1000330002i32);
2930    pub const G16_B16R16_2PLANE_444_UNORM: Self = Self(1000330003i32);
2931    pub const A4R4G4B4_UNORM_PACK16: Self = Self(1000340000i32);
2932    pub const A4B4G4R4_UNORM_PACK16: Self = Self(1000340001i32);
2933    pub const ASTC_4x4_SFLOAT_BLOCK: Self = Self(1000066000i32);
2934    pub const ASTC_5x4_SFLOAT_BLOCK: Self = Self(1000066001i32);
2935    pub const ASTC_5x5_SFLOAT_BLOCK: Self = Self(1000066002i32);
2936    pub const ASTC_6x5_SFLOAT_BLOCK: Self = Self(1000066003i32);
2937    pub const ASTC_6x6_SFLOAT_BLOCK: Self = Self(1000066004i32);
2938    pub const ASTC_8x5_SFLOAT_BLOCK: Self = Self(1000066005i32);
2939    pub const ASTC_8x6_SFLOAT_BLOCK: Self = Self(1000066006i32);
2940    pub const ASTC_8x8_SFLOAT_BLOCK: Self = Self(1000066007i32);
2941    pub const ASTC_10x5_SFLOAT_BLOCK: Self = Self(1000066008i32);
2942    pub const ASTC_10x6_SFLOAT_BLOCK: Self = Self(1000066009i32);
2943    pub const ASTC_10x8_SFLOAT_BLOCK: Self = Self(1000066010i32);
2944    pub const ASTC_10x10_SFLOAT_BLOCK: Self = Self(1000066011i32);
2945    pub const ASTC_12x10_SFLOAT_BLOCK: Self = Self(1000066012i32);
2946    pub const ASTC_12x12_SFLOAT_BLOCK: Self = Self(1000066013i32);
2947    pub const A1B5G5R5_UNORM_PACK16: Self = Self(1000470000i32);
2948    pub const A8_UNORM: Self = Self(1000470001i32);
2949    pub const PVRTC1_2BPP_UNORM_BLOCK: Self = Self(1000054000i32);
2950    pub const PVRTC1_4BPP_UNORM_BLOCK: Self = Self(1000054001i32);
2951    pub const PVRTC2_2BPP_UNORM_BLOCK: Self = Self(1000054002i32);
2952    pub const PVRTC2_4BPP_UNORM_BLOCK: Self = Self(1000054003i32);
2953    pub const PVRTC1_2BPP_SRGB_BLOCK: Self = Self(1000054004i32);
2954    pub const PVRTC1_4BPP_SRGB_BLOCK: Self = Self(1000054005i32);
2955    pub const PVRTC2_2BPP_SRGB_BLOCK: Self = Self(1000054006i32);
2956    pub const PVRTC2_4BPP_SRGB_BLOCK: Self = Self(1000054007i32);
2957    pub const ASTC_3x3x3_UNORM_BLOCK: Self = Self(1000288000i32);
2958    pub const ASTC_3x3x3_SRGB_BLOCK: Self = Self(1000288001i32);
2959    pub const ASTC_3x3x3_SFLOAT_BLOCK: Self = Self(1000288002i32);
2960    pub const ASTC_4x3x3_UNORM_BLOCK: Self = Self(1000288003i32);
2961    pub const ASTC_4x3x3_SRGB_BLOCK: Self = Self(1000288004i32);
2962    pub const ASTC_4x3x3_SFLOAT_BLOCK: Self = Self(1000288005i32);
2963    pub const ASTC_4x4x3_UNORM_BLOCK: Self = Self(1000288006i32);
2964    pub const ASTC_4x4x3_SRGB_BLOCK: Self = Self(1000288007i32);
2965    pub const ASTC_4x4x3_SFLOAT_BLOCK: Self = Self(1000288008i32);
2966    pub const ASTC_4x4x4_UNORM_BLOCK: Self = Self(1000288009i32);
2967    pub const ASTC_4x4x4_SRGB_BLOCK: Self = Self(1000288010i32);
2968    pub const ASTC_4x4x4_SFLOAT_BLOCK: Self = Self(1000288011i32);
2969    pub const ASTC_5x4x4_UNORM_BLOCK: Self = Self(1000288012i32);
2970    pub const ASTC_5x4x4_SRGB_BLOCK: Self = Self(1000288013i32);
2971    pub const ASTC_5x4x4_SFLOAT_BLOCK: Self = Self(1000288014i32);
2972    pub const ASTC_5x5x4_UNORM_BLOCK: Self = Self(1000288015i32);
2973    pub const ASTC_5x5x4_SRGB_BLOCK: Self = Self(1000288016i32);
2974    pub const ASTC_5x5x4_SFLOAT_BLOCK: Self = Self(1000288017i32);
2975    pub const ASTC_5x5x5_UNORM_BLOCK: Self = Self(1000288018i32);
2976    pub const ASTC_5x5x5_SRGB_BLOCK: Self = Self(1000288019i32);
2977    pub const ASTC_5x5x5_SFLOAT_BLOCK: Self = Self(1000288020i32);
2978    pub const ASTC_6x5x5_UNORM_BLOCK: Self = Self(1000288021i32);
2979    pub const ASTC_6x5x5_SRGB_BLOCK: Self = Self(1000288022i32);
2980    pub const ASTC_6x5x5_SFLOAT_BLOCK: Self = Self(1000288023i32);
2981    pub const ASTC_6x6x5_UNORM_BLOCK: Self = Self(1000288024i32);
2982    pub const ASTC_6x6x5_SRGB_BLOCK: Self = Self(1000288025i32);
2983    pub const ASTC_6x6x5_SFLOAT_BLOCK: Self = Self(1000288026i32);
2984    pub const ASTC_6x6x6_UNORM_BLOCK: Self = Self(1000288027i32);
2985    pub const ASTC_6x6x6_SRGB_BLOCK: Self = Self(1000288028i32);
2986    pub const ASTC_6x6x6_SFLOAT_BLOCK: Self = Self(1000288029i32);
2987    pub const R8_BOOL: Self = Self(1000460000i32);
2988    pub const R16_SFLOAT_FPENCODING_BFLOAT16: Self = Self(1000460001i32);
2989    pub const R8_SFLOAT_FPENCODING_FLOAT8E4M3: Self = Self(1000460002i32);
2990    pub const R8_SFLOAT_FPENCODING_FLOAT8E5M2: Self = Self(1000460003i32);
2991    pub const R16G16_SFIXED5: Self = Self(1000464000i32);
2992    pub const R16G16_S10_5: Self = Self::R16G16_SFIXED5;
2993    pub const R10X6_UINT_PACK16: Self = Self(1000609000i32);
2994    pub const R10X6G10X6_UINT_2PACK16: Self = Self(1000609001i32);
2995    pub const R10X6G10X6B10X6A10X6_UINT_4PACK16: Self = Self(1000609002i32);
2996    pub const R12X4_UINT_PACK16: Self = Self(1000609003i32);
2997    pub const R12X4G12X4_UINT_2PACK16: Self = Self(1000609004i32);
2998    pub const R12X4G12X4B12X4A12X4_UINT_4PACK16: Self = Self(1000609005i32);
2999    pub const R14X2_UINT_PACK16: Self = Self(1000609006i32);
3000    pub const R14X2G14X2_UINT_2PACK16: Self = Self(1000609007i32);
3001    pub const R14X2G14X2B14X2A14X2_UINT_4PACK16: Self = Self(1000609008i32);
3002    pub const R14X2_UNORM_PACK16: Self = Self(1000609009i32);
3003    pub const R14X2G14X2_UNORM_2PACK16: Self = Self(1000609010i32);
3004    pub const R14X2G14X2B14X2A14X2_UNORM_4PACK16: Self = Self(1000609011i32);
3005    pub const G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16: Self = Self(1000609012i32);
3006    pub const G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16: Self = Self(1000609013i32);
3007    #[inline]
3008    pub const fn from_raw(value: i32) -> Self {
3009        Self(value)
3010    }
3011    #[inline]
3012    pub const fn as_raw(self) -> i32 {
3013        self.0
3014    }
3015}
3016impl core::fmt::Debug for Format {
3017    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3018        match self.0 {
3019            0i32 => f.write_str("UNDEFINED"),
3020            1i32 => f.write_str("R4G4_UNORM_PACK8"),
3021            2i32 => f.write_str("R4G4B4A4_UNORM_PACK16"),
3022            3i32 => f.write_str("B4G4R4A4_UNORM_PACK16"),
3023            4i32 => f.write_str("R5G6B5_UNORM_PACK16"),
3024            5i32 => f.write_str("B5G6R5_UNORM_PACK16"),
3025            6i32 => f.write_str("R5G5B5A1_UNORM_PACK16"),
3026            7i32 => f.write_str("B5G5R5A1_UNORM_PACK16"),
3027            8i32 => f.write_str("A1R5G5B5_UNORM_PACK16"),
3028            9i32 => f.write_str("R8_UNORM"),
3029            10i32 => f.write_str("R8_SNORM"),
3030            11i32 => f.write_str("R8_USCALED"),
3031            12i32 => f.write_str("R8_SSCALED"),
3032            13i32 => f.write_str("R8_UINT"),
3033            14i32 => f.write_str("R8_SINT"),
3034            15i32 => f.write_str("R8_SRGB"),
3035            16i32 => f.write_str("R8G8_UNORM"),
3036            17i32 => f.write_str("R8G8_SNORM"),
3037            18i32 => f.write_str("R8G8_USCALED"),
3038            19i32 => f.write_str("R8G8_SSCALED"),
3039            20i32 => f.write_str("R8G8_UINT"),
3040            21i32 => f.write_str("R8G8_SINT"),
3041            22i32 => f.write_str("R8G8_SRGB"),
3042            23i32 => f.write_str("R8G8B8_UNORM"),
3043            24i32 => f.write_str("R8G8B8_SNORM"),
3044            25i32 => f.write_str("R8G8B8_USCALED"),
3045            26i32 => f.write_str("R8G8B8_SSCALED"),
3046            27i32 => f.write_str("R8G8B8_UINT"),
3047            28i32 => f.write_str("R8G8B8_SINT"),
3048            29i32 => f.write_str("R8G8B8_SRGB"),
3049            30i32 => f.write_str("B8G8R8_UNORM"),
3050            31i32 => f.write_str("B8G8R8_SNORM"),
3051            32i32 => f.write_str("B8G8R8_USCALED"),
3052            33i32 => f.write_str("B8G8R8_SSCALED"),
3053            34i32 => f.write_str("B8G8R8_UINT"),
3054            35i32 => f.write_str("B8G8R8_SINT"),
3055            36i32 => f.write_str("B8G8R8_SRGB"),
3056            37i32 => f.write_str("R8G8B8A8_UNORM"),
3057            38i32 => f.write_str("R8G8B8A8_SNORM"),
3058            39i32 => f.write_str("R8G8B8A8_USCALED"),
3059            40i32 => f.write_str("R8G8B8A8_SSCALED"),
3060            41i32 => f.write_str("R8G8B8A8_UINT"),
3061            42i32 => f.write_str("R8G8B8A8_SINT"),
3062            43i32 => f.write_str("R8G8B8A8_SRGB"),
3063            44i32 => f.write_str("B8G8R8A8_UNORM"),
3064            45i32 => f.write_str("B8G8R8A8_SNORM"),
3065            46i32 => f.write_str("B8G8R8A8_USCALED"),
3066            47i32 => f.write_str("B8G8R8A8_SSCALED"),
3067            48i32 => f.write_str("B8G8R8A8_UINT"),
3068            49i32 => f.write_str("B8G8R8A8_SINT"),
3069            50i32 => f.write_str("B8G8R8A8_SRGB"),
3070            51i32 => f.write_str("A8B8G8R8_UNORM_PACK32"),
3071            52i32 => f.write_str("A8B8G8R8_SNORM_PACK32"),
3072            53i32 => f.write_str("A8B8G8R8_USCALED_PACK32"),
3073            54i32 => f.write_str("A8B8G8R8_SSCALED_PACK32"),
3074            55i32 => f.write_str("A8B8G8R8_UINT_PACK32"),
3075            56i32 => f.write_str("A8B8G8R8_SINT_PACK32"),
3076            57i32 => f.write_str("A8B8G8R8_SRGB_PACK32"),
3077            58i32 => f.write_str("A2R10G10B10_UNORM_PACK32"),
3078            59i32 => f.write_str("A2R10G10B10_SNORM_PACK32"),
3079            60i32 => f.write_str("A2R10G10B10_USCALED_PACK32"),
3080            61i32 => f.write_str("A2R10G10B10_SSCALED_PACK32"),
3081            62i32 => f.write_str("A2R10G10B10_UINT_PACK32"),
3082            63i32 => f.write_str("A2R10G10B10_SINT_PACK32"),
3083            64i32 => f.write_str("A2B10G10R10_UNORM_PACK32"),
3084            65i32 => f.write_str("A2B10G10R10_SNORM_PACK32"),
3085            66i32 => f.write_str("A2B10G10R10_USCALED_PACK32"),
3086            67i32 => f.write_str("A2B10G10R10_SSCALED_PACK32"),
3087            68i32 => f.write_str("A2B10G10R10_UINT_PACK32"),
3088            69i32 => f.write_str("A2B10G10R10_SINT_PACK32"),
3089            70i32 => f.write_str("R16_UNORM"),
3090            71i32 => f.write_str("R16_SNORM"),
3091            72i32 => f.write_str("R16_USCALED"),
3092            73i32 => f.write_str("R16_SSCALED"),
3093            74i32 => f.write_str("R16_UINT"),
3094            75i32 => f.write_str("R16_SINT"),
3095            76i32 => f.write_str("R16_SFLOAT"),
3096            77i32 => f.write_str("R16G16_UNORM"),
3097            78i32 => f.write_str("R16G16_SNORM"),
3098            79i32 => f.write_str("R16G16_USCALED"),
3099            80i32 => f.write_str("R16G16_SSCALED"),
3100            81i32 => f.write_str("R16G16_UINT"),
3101            82i32 => f.write_str("R16G16_SINT"),
3102            83i32 => f.write_str("R16G16_SFLOAT"),
3103            84i32 => f.write_str("R16G16B16_UNORM"),
3104            85i32 => f.write_str("R16G16B16_SNORM"),
3105            86i32 => f.write_str("R16G16B16_USCALED"),
3106            87i32 => f.write_str("R16G16B16_SSCALED"),
3107            88i32 => f.write_str("R16G16B16_UINT"),
3108            89i32 => f.write_str("R16G16B16_SINT"),
3109            90i32 => f.write_str("R16G16B16_SFLOAT"),
3110            91i32 => f.write_str("R16G16B16A16_UNORM"),
3111            92i32 => f.write_str("R16G16B16A16_SNORM"),
3112            93i32 => f.write_str("R16G16B16A16_USCALED"),
3113            94i32 => f.write_str("R16G16B16A16_SSCALED"),
3114            95i32 => f.write_str("R16G16B16A16_UINT"),
3115            96i32 => f.write_str("R16G16B16A16_SINT"),
3116            97i32 => f.write_str("R16G16B16A16_SFLOAT"),
3117            98i32 => f.write_str("R32_UINT"),
3118            99i32 => f.write_str("R32_SINT"),
3119            100i32 => f.write_str("R32_SFLOAT"),
3120            101i32 => f.write_str("R32G32_UINT"),
3121            102i32 => f.write_str("R32G32_SINT"),
3122            103i32 => f.write_str("R32G32_SFLOAT"),
3123            104i32 => f.write_str("R32G32B32_UINT"),
3124            105i32 => f.write_str("R32G32B32_SINT"),
3125            106i32 => f.write_str("R32G32B32_SFLOAT"),
3126            107i32 => f.write_str("R32G32B32A32_UINT"),
3127            108i32 => f.write_str("R32G32B32A32_SINT"),
3128            109i32 => f.write_str("R32G32B32A32_SFLOAT"),
3129            110i32 => f.write_str("R64_UINT"),
3130            111i32 => f.write_str("R64_SINT"),
3131            112i32 => f.write_str("R64_SFLOAT"),
3132            113i32 => f.write_str("R64G64_UINT"),
3133            114i32 => f.write_str("R64G64_SINT"),
3134            115i32 => f.write_str("R64G64_SFLOAT"),
3135            116i32 => f.write_str("R64G64B64_UINT"),
3136            117i32 => f.write_str("R64G64B64_SINT"),
3137            118i32 => f.write_str("R64G64B64_SFLOAT"),
3138            119i32 => f.write_str("R64G64B64A64_UINT"),
3139            120i32 => f.write_str("R64G64B64A64_SINT"),
3140            121i32 => f.write_str("R64G64B64A64_SFLOAT"),
3141            122i32 => f.write_str("B10G11R11_UFLOAT_PACK32"),
3142            123i32 => f.write_str("E5B9G9R9_UFLOAT_PACK32"),
3143            124i32 => f.write_str("D16_UNORM"),
3144            125i32 => f.write_str("X8_D24_UNORM_PACK32"),
3145            126i32 => f.write_str("D32_SFLOAT"),
3146            127i32 => f.write_str("S8_UINT"),
3147            128i32 => f.write_str("D16_UNORM_S8_UINT"),
3148            129i32 => f.write_str("D24_UNORM_S8_UINT"),
3149            130i32 => f.write_str("D32_SFLOAT_S8_UINT"),
3150            131i32 => f.write_str("BC1_RGB_UNORM_BLOCK"),
3151            132i32 => f.write_str("BC1_RGB_SRGB_BLOCK"),
3152            133i32 => f.write_str("BC1_RGBA_UNORM_BLOCK"),
3153            134i32 => f.write_str("BC1_RGBA_SRGB_BLOCK"),
3154            135i32 => f.write_str("BC2_UNORM_BLOCK"),
3155            136i32 => f.write_str("BC2_SRGB_BLOCK"),
3156            137i32 => f.write_str("BC3_UNORM_BLOCK"),
3157            138i32 => f.write_str("BC3_SRGB_BLOCK"),
3158            139i32 => f.write_str("BC4_UNORM_BLOCK"),
3159            140i32 => f.write_str("BC4_SNORM_BLOCK"),
3160            141i32 => f.write_str("BC5_UNORM_BLOCK"),
3161            142i32 => f.write_str("BC5_SNORM_BLOCK"),
3162            143i32 => f.write_str("BC6H_UFLOAT_BLOCK"),
3163            144i32 => f.write_str("BC6H_SFLOAT_BLOCK"),
3164            145i32 => f.write_str("BC7_UNORM_BLOCK"),
3165            146i32 => f.write_str("BC7_SRGB_BLOCK"),
3166            147i32 => f.write_str("ETC2_R8G8B8_UNORM_BLOCK"),
3167            148i32 => f.write_str("ETC2_R8G8B8_SRGB_BLOCK"),
3168            149i32 => f.write_str("ETC2_R8G8B8A1_UNORM_BLOCK"),
3169            150i32 => f.write_str("ETC2_R8G8B8A1_SRGB_BLOCK"),
3170            151i32 => f.write_str("ETC2_R8G8B8A8_UNORM_BLOCK"),
3171            152i32 => f.write_str("ETC2_R8G8B8A8_SRGB_BLOCK"),
3172            153i32 => f.write_str("EAC_R11_UNORM_BLOCK"),
3173            154i32 => f.write_str("EAC_R11_SNORM_BLOCK"),
3174            155i32 => f.write_str("EAC_R11G11_UNORM_BLOCK"),
3175            156i32 => f.write_str("EAC_R11G11_SNORM_BLOCK"),
3176            157i32 => f.write_str("ASTC_4x4_UNORM_BLOCK"),
3177            158i32 => f.write_str("ASTC_4x4_SRGB_BLOCK"),
3178            159i32 => f.write_str("ASTC_5x4_UNORM_BLOCK"),
3179            160i32 => f.write_str("ASTC_5x4_SRGB_BLOCK"),
3180            161i32 => f.write_str("ASTC_5x5_UNORM_BLOCK"),
3181            162i32 => f.write_str("ASTC_5x5_SRGB_BLOCK"),
3182            163i32 => f.write_str("ASTC_6x5_UNORM_BLOCK"),
3183            164i32 => f.write_str("ASTC_6x5_SRGB_BLOCK"),
3184            165i32 => f.write_str("ASTC_6x6_UNORM_BLOCK"),
3185            166i32 => f.write_str("ASTC_6x6_SRGB_BLOCK"),
3186            167i32 => f.write_str("ASTC_8x5_UNORM_BLOCK"),
3187            168i32 => f.write_str("ASTC_8x5_SRGB_BLOCK"),
3188            169i32 => f.write_str("ASTC_8x6_UNORM_BLOCK"),
3189            170i32 => f.write_str("ASTC_8x6_SRGB_BLOCK"),
3190            171i32 => f.write_str("ASTC_8x8_UNORM_BLOCK"),
3191            172i32 => f.write_str("ASTC_8x8_SRGB_BLOCK"),
3192            173i32 => f.write_str("ASTC_10x5_UNORM_BLOCK"),
3193            174i32 => f.write_str("ASTC_10x5_SRGB_BLOCK"),
3194            175i32 => f.write_str("ASTC_10x6_UNORM_BLOCK"),
3195            176i32 => f.write_str("ASTC_10x6_SRGB_BLOCK"),
3196            177i32 => f.write_str("ASTC_10x8_UNORM_BLOCK"),
3197            178i32 => f.write_str("ASTC_10x8_SRGB_BLOCK"),
3198            179i32 => f.write_str("ASTC_10x10_UNORM_BLOCK"),
3199            180i32 => f.write_str("ASTC_10x10_SRGB_BLOCK"),
3200            181i32 => f.write_str("ASTC_12x10_UNORM_BLOCK"),
3201            182i32 => f.write_str("ASTC_12x10_SRGB_BLOCK"),
3202            183i32 => f.write_str("ASTC_12x12_UNORM_BLOCK"),
3203            184i32 => f.write_str("ASTC_12x12_SRGB_BLOCK"),
3204            1000156000i32 => f.write_str("G8B8G8R8_422_UNORM"),
3205            1000156001i32 => f.write_str("B8G8R8G8_422_UNORM"),
3206            1000156002i32 => f.write_str("G8_B8_R8_3PLANE_420_UNORM"),
3207            1000156003i32 => f.write_str("G8_B8R8_2PLANE_420_UNORM"),
3208            1000156004i32 => f.write_str("G8_B8_R8_3PLANE_422_UNORM"),
3209            1000156005i32 => f.write_str("G8_B8R8_2PLANE_422_UNORM"),
3210            1000156006i32 => f.write_str("G8_B8_R8_3PLANE_444_UNORM"),
3211            1000156007i32 => f.write_str("R10X6_UNORM_PACK16"),
3212            1000156008i32 => f.write_str("R10X6G10X6_UNORM_2PACK16"),
3213            1000156009i32 => f.write_str("R10X6G10X6B10X6A10X6_UNORM_4PACK16"),
3214            1000156010i32 => f.write_str("G10X6B10X6G10X6R10X6_422_UNORM_4PACK16"),
3215            1000156011i32 => f.write_str("B10X6G10X6R10X6G10X6_422_UNORM_4PACK16"),
3216            1000156012i32 => f.write_str("G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16"),
3217            1000156013i32 => f.write_str("G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16"),
3218            1000156014i32 => f.write_str("G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16"),
3219            1000156015i32 => f.write_str("G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16"),
3220            1000156016i32 => f.write_str("G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16"),
3221            1000156017i32 => f.write_str("R12X4_UNORM_PACK16"),
3222            1000156018i32 => f.write_str("R12X4G12X4_UNORM_2PACK16"),
3223            1000156019i32 => f.write_str("R12X4G12X4B12X4A12X4_UNORM_4PACK16"),
3224            1000156020i32 => f.write_str("G12X4B12X4G12X4R12X4_422_UNORM_4PACK16"),
3225            1000156021i32 => f.write_str("B12X4G12X4R12X4G12X4_422_UNORM_4PACK16"),
3226            1000156022i32 => f.write_str("G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16"),
3227            1000156023i32 => f.write_str("G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16"),
3228            1000156024i32 => f.write_str("G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16"),
3229            1000156025i32 => f.write_str("G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16"),
3230            1000156026i32 => f.write_str("G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16"),
3231            1000156027i32 => f.write_str("G16B16G16R16_422_UNORM"),
3232            1000156028i32 => f.write_str("B16G16R16G16_422_UNORM"),
3233            1000156029i32 => f.write_str("G16_B16_R16_3PLANE_420_UNORM"),
3234            1000156030i32 => f.write_str("G16_B16R16_2PLANE_420_UNORM"),
3235            1000156031i32 => f.write_str("G16_B16_R16_3PLANE_422_UNORM"),
3236            1000156032i32 => f.write_str("G16_B16R16_2PLANE_422_UNORM"),
3237            1000156033i32 => f.write_str("G16_B16_R16_3PLANE_444_UNORM"),
3238            1000330000i32 => f.write_str("G8_B8R8_2PLANE_444_UNORM"),
3239            1000330001i32 => f.write_str("G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16"),
3240            1000330002i32 => f.write_str("G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16"),
3241            1000330003i32 => f.write_str("G16_B16R16_2PLANE_444_UNORM"),
3242            1000340000i32 => f.write_str("A4R4G4B4_UNORM_PACK16"),
3243            1000340001i32 => f.write_str("A4B4G4R4_UNORM_PACK16"),
3244            1000066000i32 => f.write_str("ASTC_4x4_SFLOAT_BLOCK"),
3245            1000066001i32 => f.write_str("ASTC_5x4_SFLOAT_BLOCK"),
3246            1000066002i32 => f.write_str("ASTC_5x5_SFLOAT_BLOCK"),
3247            1000066003i32 => f.write_str("ASTC_6x5_SFLOAT_BLOCK"),
3248            1000066004i32 => f.write_str("ASTC_6x6_SFLOAT_BLOCK"),
3249            1000066005i32 => f.write_str("ASTC_8x5_SFLOAT_BLOCK"),
3250            1000066006i32 => f.write_str("ASTC_8x6_SFLOAT_BLOCK"),
3251            1000066007i32 => f.write_str("ASTC_8x8_SFLOAT_BLOCK"),
3252            1000066008i32 => f.write_str("ASTC_10x5_SFLOAT_BLOCK"),
3253            1000066009i32 => f.write_str("ASTC_10x6_SFLOAT_BLOCK"),
3254            1000066010i32 => f.write_str("ASTC_10x8_SFLOAT_BLOCK"),
3255            1000066011i32 => f.write_str("ASTC_10x10_SFLOAT_BLOCK"),
3256            1000066012i32 => f.write_str("ASTC_12x10_SFLOAT_BLOCK"),
3257            1000066013i32 => f.write_str("ASTC_12x12_SFLOAT_BLOCK"),
3258            1000470000i32 => f.write_str("A1B5G5R5_UNORM_PACK16"),
3259            1000470001i32 => f.write_str("A8_UNORM"),
3260            1000054000i32 => f.write_str("PVRTC1_2BPP_UNORM_BLOCK"),
3261            1000054001i32 => f.write_str("PVRTC1_4BPP_UNORM_BLOCK"),
3262            1000054002i32 => f.write_str("PVRTC2_2BPP_UNORM_BLOCK"),
3263            1000054003i32 => f.write_str("PVRTC2_4BPP_UNORM_BLOCK"),
3264            1000054004i32 => f.write_str("PVRTC1_2BPP_SRGB_BLOCK"),
3265            1000054005i32 => f.write_str("PVRTC1_4BPP_SRGB_BLOCK"),
3266            1000054006i32 => f.write_str("PVRTC2_2BPP_SRGB_BLOCK"),
3267            1000054007i32 => f.write_str("PVRTC2_4BPP_SRGB_BLOCK"),
3268            1000288000i32 => f.write_str("ASTC_3x3x3_UNORM_BLOCK"),
3269            1000288001i32 => f.write_str("ASTC_3x3x3_SRGB_BLOCK"),
3270            1000288002i32 => f.write_str("ASTC_3x3x3_SFLOAT_BLOCK"),
3271            1000288003i32 => f.write_str("ASTC_4x3x3_UNORM_BLOCK"),
3272            1000288004i32 => f.write_str("ASTC_4x3x3_SRGB_BLOCK"),
3273            1000288005i32 => f.write_str("ASTC_4x3x3_SFLOAT_BLOCK"),
3274            1000288006i32 => f.write_str("ASTC_4x4x3_UNORM_BLOCK"),
3275            1000288007i32 => f.write_str("ASTC_4x4x3_SRGB_BLOCK"),
3276            1000288008i32 => f.write_str("ASTC_4x4x3_SFLOAT_BLOCK"),
3277            1000288009i32 => f.write_str("ASTC_4x4x4_UNORM_BLOCK"),
3278            1000288010i32 => f.write_str("ASTC_4x4x4_SRGB_BLOCK"),
3279            1000288011i32 => f.write_str("ASTC_4x4x4_SFLOAT_BLOCK"),
3280            1000288012i32 => f.write_str("ASTC_5x4x4_UNORM_BLOCK"),
3281            1000288013i32 => f.write_str("ASTC_5x4x4_SRGB_BLOCK"),
3282            1000288014i32 => f.write_str("ASTC_5x4x4_SFLOAT_BLOCK"),
3283            1000288015i32 => f.write_str("ASTC_5x5x4_UNORM_BLOCK"),
3284            1000288016i32 => f.write_str("ASTC_5x5x4_SRGB_BLOCK"),
3285            1000288017i32 => f.write_str("ASTC_5x5x4_SFLOAT_BLOCK"),
3286            1000288018i32 => f.write_str("ASTC_5x5x5_UNORM_BLOCK"),
3287            1000288019i32 => f.write_str("ASTC_5x5x5_SRGB_BLOCK"),
3288            1000288020i32 => f.write_str("ASTC_5x5x5_SFLOAT_BLOCK"),
3289            1000288021i32 => f.write_str("ASTC_6x5x5_UNORM_BLOCK"),
3290            1000288022i32 => f.write_str("ASTC_6x5x5_SRGB_BLOCK"),
3291            1000288023i32 => f.write_str("ASTC_6x5x5_SFLOAT_BLOCK"),
3292            1000288024i32 => f.write_str("ASTC_6x6x5_UNORM_BLOCK"),
3293            1000288025i32 => f.write_str("ASTC_6x6x5_SRGB_BLOCK"),
3294            1000288026i32 => f.write_str("ASTC_6x6x5_SFLOAT_BLOCK"),
3295            1000288027i32 => f.write_str("ASTC_6x6x6_UNORM_BLOCK"),
3296            1000288028i32 => f.write_str("ASTC_6x6x6_SRGB_BLOCK"),
3297            1000288029i32 => f.write_str("ASTC_6x6x6_SFLOAT_BLOCK"),
3298            1000460000i32 => f.write_str("R8_BOOL"),
3299            1000460001i32 => f.write_str("R16_SFLOAT_FPENCODING_BFLOAT16"),
3300            1000460002i32 => f.write_str("R8_SFLOAT_FPENCODING_FLOAT8E4M3"),
3301            1000460003i32 => f.write_str("R8_SFLOAT_FPENCODING_FLOAT8E5M2"),
3302            1000464000i32 => f.write_str("R16G16_SFIXED5"),
3303            1000609000i32 => f.write_str("R10X6_UINT_PACK16"),
3304            1000609001i32 => f.write_str("R10X6G10X6_UINT_2PACK16"),
3305            1000609002i32 => f.write_str("R10X6G10X6B10X6A10X6_UINT_4PACK16"),
3306            1000609003i32 => f.write_str("R12X4_UINT_PACK16"),
3307            1000609004i32 => f.write_str("R12X4G12X4_UINT_2PACK16"),
3308            1000609005i32 => f.write_str("R12X4G12X4B12X4A12X4_UINT_4PACK16"),
3309            1000609006i32 => f.write_str("R14X2_UINT_PACK16"),
3310            1000609007i32 => f.write_str("R14X2G14X2_UINT_2PACK16"),
3311            1000609008i32 => f.write_str("R14X2G14X2B14X2A14X2_UINT_4PACK16"),
3312            1000609009i32 => f.write_str("R14X2_UNORM_PACK16"),
3313            1000609010i32 => f.write_str("R14X2G14X2_UNORM_2PACK16"),
3314            1000609011i32 => f.write_str("R14X2G14X2B14X2A14X2_UNORM_4PACK16"),
3315            1000609012i32 => f.write_str("G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16"),
3316            1000609013i32 => f.write_str("G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16"),
3317            other => write!(f, "{}({})", stringify!(Format), other),
3318        }
3319    }
3320}
3321impl core::fmt::Display for Format {
3322    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3323        core::fmt::Debug::fmt(self, f)
3324    }
3325}
3326impl core::error::Error for Format {}
3327///[`VkFragmentShadingRateCombinerOpKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateCombinerOpKHR.html)
3328#[repr(transparent)]
3329#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3330#[doc(alias = "VkFragmentShadingRateCombinerOpKHR")]
3331pub struct FragmentShadingRateCombinerOpKHR(i32);
3332impl FragmentShadingRateCombinerOpKHR {
3333    pub const KEEP: Self = Self(0i32);
3334    pub const REPLACE: Self = Self(1i32);
3335    pub const MIN: Self = Self(2i32);
3336    pub const MAX: Self = Self(3i32);
3337    pub const MUL: Self = Self(4i32);
3338    #[inline]
3339    pub const fn from_raw(value: i32) -> Self {
3340        Self(value)
3341    }
3342    #[inline]
3343    pub const fn as_raw(self) -> i32 {
3344        self.0
3345    }
3346}
3347impl core::fmt::Debug for FragmentShadingRateCombinerOpKHR {
3348    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3349        match self.0 {
3350            0i32 => f.write_str("KEEP"),
3351            1i32 => f.write_str("REPLACE"),
3352            2i32 => f.write_str("MIN"),
3353            3i32 => f.write_str("MAX"),
3354            4i32 => f.write_str("MUL"),
3355            other => {
3356                write!(f, "{}({})", stringify!(FragmentShadingRateCombinerOpKHR), other)
3357            }
3358        }
3359    }
3360}
3361impl core::fmt::Display for FragmentShadingRateCombinerOpKHR {
3362    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3363        core::fmt::Debug::fmt(self, f)
3364    }
3365}
3366impl core::error::Error for FragmentShadingRateCombinerOpKHR {}
3367///[`VkFragmentShadingRateNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateNV.html)
3368#[repr(transparent)]
3369#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3370#[doc(alias = "VkFragmentShadingRateNV")]
3371pub struct FragmentShadingRateNV(i32);
3372impl FragmentShadingRateNV {
3373    pub const _1_INVOCATION_PER_PIXEL: Self = Self(0i32);
3374    pub const _1_INVOCATION_PER_1X2_PIXELS: Self = Self(1i32);
3375    pub const _1_INVOCATION_PER_2X1_PIXELS: Self = Self(4i32);
3376    pub const _1_INVOCATION_PER_2X2_PIXELS: Self = Self(5i32);
3377    pub const _1_INVOCATION_PER_2X4_PIXELS: Self = Self(6i32);
3378    pub const _1_INVOCATION_PER_4X2_PIXELS: Self = Self(9i32);
3379    pub const _1_INVOCATION_PER_4X4_PIXELS: Self = Self(10i32);
3380    pub const _2_INVOCATIONS_PER_PIXEL: Self = Self(11i32);
3381    pub const _4_INVOCATIONS_PER_PIXEL: Self = Self(12i32);
3382    pub const _8_INVOCATIONS_PER_PIXEL: Self = Self(13i32);
3383    pub const _16_INVOCATIONS_PER_PIXEL: Self = Self(14i32);
3384    pub const NO_INVOCATIONS: Self = Self(15i32);
3385    #[inline]
3386    pub const fn from_raw(value: i32) -> Self {
3387        Self(value)
3388    }
3389    #[inline]
3390    pub const fn as_raw(self) -> i32 {
3391        self.0
3392    }
3393}
3394impl core::fmt::Debug for FragmentShadingRateNV {
3395    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3396        match self.0 {
3397            0i32 => f.write_str("_1_INVOCATION_PER_PIXEL"),
3398            1i32 => f.write_str("_1_INVOCATION_PER_1X2_PIXELS"),
3399            4i32 => f.write_str("_1_INVOCATION_PER_2X1_PIXELS"),
3400            5i32 => f.write_str("_1_INVOCATION_PER_2X2_PIXELS"),
3401            6i32 => f.write_str("_1_INVOCATION_PER_2X4_PIXELS"),
3402            9i32 => f.write_str("_1_INVOCATION_PER_4X2_PIXELS"),
3403            10i32 => f.write_str("_1_INVOCATION_PER_4X4_PIXELS"),
3404            11i32 => f.write_str("_2_INVOCATIONS_PER_PIXEL"),
3405            12i32 => f.write_str("_4_INVOCATIONS_PER_PIXEL"),
3406            13i32 => f.write_str("_8_INVOCATIONS_PER_PIXEL"),
3407            14i32 => f.write_str("_16_INVOCATIONS_PER_PIXEL"),
3408            15i32 => f.write_str("NO_INVOCATIONS"),
3409            other => write!(f, "{}({})", stringify!(FragmentShadingRateNV), other),
3410        }
3411    }
3412}
3413impl core::fmt::Display for FragmentShadingRateNV {
3414    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3415        core::fmt::Debug::fmt(self, f)
3416    }
3417}
3418impl core::error::Error for FragmentShadingRateNV {}
3419///[`VkFragmentShadingRateTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateTypeNV.html)
3420#[repr(transparent)]
3421#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3422#[doc(alias = "VkFragmentShadingRateTypeNV")]
3423pub struct FragmentShadingRateTypeNV(i32);
3424impl FragmentShadingRateTypeNV {
3425    pub const FRAGMENT_SIZE: Self = Self(0i32);
3426    pub const ENUMS: Self = Self(1i32);
3427    #[inline]
3428    pub const fn from_raw(value: i32) -> Self {
3429        Self(value)
3430    }
3431    #[inline]
3432    pub const fn as_raw(self) -> i32 {
3433        self.0
3434    }
3435}
3436impl core::fmt::Debug for FragmentShadingRateTypeNV {
3437    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3438        match self.0 {
3439            0i32 => f.write_str("FRAGMENT_SIZE"),
3440            1i32 => f.write_str("ENUMS"),
3441            other => write!(f, "{}({})", stringify!(FragmentShadingRateTypeNV), other),
3442        }
3443    }
3444}
3445impl core::fmt::Display for FragmentShadingRateTypeNV {
3446    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3447        core::fmt::Debug::fmt(self, f)
3448    }
3449}
3450impl core::error::Error for FragmentShadingRateTypeNV {}
3451///[`VkFrontFace`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrontFace.html)
3452#[repr(transparent)]
3453#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3454#[doc(alias = "VkFrontFace")]
3455pub struct FrontFace(i32);
3456impl FrontFace {
3457    pub const COUNTER_CLOCKWISE: Self = Self(0i32);
3458    pub const CLOCKWISE: Self = Self(1i32);
3459    #[inline]
3460    pub const fn from_raw(value: i32) -> Self {
3461        Self(value)
3462    }
3463    #[inline]
3464    pub const fn as_raw(self) -> i32 {
3465        self.0
3466    }
3467}
3468impl core::fmt::Debug for FrontFace {
3469    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3470        match self.0 {
3471            0i32 => f.write_str("COUNTER_CLOCKWISE"),
3472            1i32 => f.write_str("CLOCKWISE"),
3473            other => write!(f, "{}({})", stringify!(FrontFace), other),
3474        }
3475    }
3476}
3477impl core::fmt::Display for FrontFace {
3478    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3479        core::fmt::Debug::fmt(self, f)
3480    }
3481}
3482impl core::error::Error for FrontFace {}
3483///[`VkFullScreenExclusiveEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkFullScreenExclusiveEXT.html)
3484#[repr(transparent)]
3485#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3486#[doc(alias = "VkFullScreenExclusiveEXT")]
3487pub struct FullScreenExclusiveEXT(i32);
3488impl FullScreenExclusiveEXT {
3489    pub const DEFAULT: Self = Self(0i32);
3490    pub const ALLOWED: Self = Self(1i32);
3491    pub const DISALLOWED: Self = Self(2i32);
3492    pub const APPLICATION_CONTROLLED: Self = Self(3i32);
3493    #[inline]
3494    pub const fn from_raw(value: i32) -> Self {
3495        Self(value)
3496    }
3497    #[inline]
3498    pub const fn as_raw(self) -> i32 {
3499        self.0
3500    }
3501}
3502impl core::fmt::Debug for FullScreenExclusiveEXT {
3503    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3504        match self.0 {
3505            0i32 => f.write_str("DEFAULT"),
3506            1i32 => f.write_str("ALLOWED"),
3507            2i32 => f.write_str("DISALLOWED"),
3508            3i32 => f.write_str("APPLICATION_CONTROLLED"),
3509            other => write!(f, "{}({})", stringify!(FullScreenExclusiveEXT), other),
3510        }
3511    }
3512}
3513impl core::fmt::Display for FullScreenExclusiveEXT {
3514    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3515        core::fmt::Debug::fmt(self, f)
3516    }
3517}
3518impl core::error::Error for FullScreenExclusiveEXT {}
3519///[`VkGeometryTypeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryTypeKHR.html)
3520#[repr(transparent)]
3521#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3522#[doc(alias = "VkGeometryTypeKHR")]
3523pub struct GeometryTypeKHR(i32);
3524impl GeometryTypeKHR {
3525    pub const TRIANGLES: Self = Self(0i32);
3526    pub const AABBS: Self = Self(1i32);
3527    pub const INSTANCES: Self = Self(2i32);
3528    pub const SPHERES: Self = Self(1000429004i32);
3529    pub const LINEAR_SWEPT_SPHERES: Self = Self(1000429005i32);
3530    pub const DENSE_GEOMETRY_FORMAT_TRIANGLES: Self = Self(1000478000i32);
3531    #[inline]
3532    pub const fn from_raw(value: i32) -> Self {
3533        Self(value)
3534    }
3535    #[inline]
3536    pub const fn as_raw(self) -> i32 {
3537        self.0
3538    }
3539}
3540impl core::fmt::Debug for GeometryTypeKHR {
3541    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3542        match self.0 {
3543            0i32 => f.write_str("TRIANGLES"),
3544            1i32 => f.write_str("AABBS"),
3545            2i32 => f.write_str("INSTANCES"),
3546            1000429004i32 => f.write_str("SPHERES"),
3547            1000429005i32 => f.write_str("LINEAR_SWEPT_SPHERES"),
3548            1000478000i32 => f.write_str("DENSE_GEOMETRY_FORMAT_TRIANGLES"),
3549            other => write!(f, "{}({})", stringify!(GeometryTypeKHR), other),
3550        }
3551    }
3552}
3553impl core::fmt::Display for GeometryTypeKHR {
3554    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3555        core::fmt::Debug::fmt(self, f)
3556    }
3557}
3558impl core::error::Error for GeometryTypeKHR {}
3559///[`VkImageLayout`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageLayout.html)
3560#[repr(transparent)]
3561#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3562#[doc(alias = "VkImageLayout")]
3563pub struct ImageLayout(i32);
3564impl ImageLayout {
3565    ///Implicit layout an image is when its contents are undefined due to various reasons (e.g. right after creation)
3566    pub const UNDEFINED: Self = Self(0i32);
3567    ///General layout when image can be used for any kind of access
3568    pub const GENERAL: Self = Self(1i32);
3569    ///Optimal layout when image is only used for color attachment read/write
3570    pub const COLOR_ATTACHMENT_OPTIMAL: Self = Self(2i32);
3571    ///Optimal layout when image is only used for depth/stencil attachment read/write
3572    pub const DEPTH_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(3i32);
3573    ///Optimal layout when image is used for read only depth/stencil attachment and shader access
3574    pub const DEPTH_STENCIL_READ_ONLY_OPTIMAL: Self = Self(4i32);
3575    ///Optimal layout when image is used for read only shader access
3576    pub const SHADER_READ_ONLY_OPTIMAL: Self = Self(5i32);
3577    ///Optimal layout when image is used only as source of transfer operations
3578    pub const TRANSFER_SRC_OPTIMAL: Self = Self(6i32);
3579    ///Optimal layout when image is used only as destination of transfer operations
3580    pub const TRANSFER_DST_OPTIMAL: Self = Self(7i32);
3581    ///Initial layout used when the data is populated by the CPU
3582    pub const PREINITIALIZED: Self = Self(8i32);
3583    pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1000117000i32);
3584    pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: Self = Self(1000117001i32);
3585    pub const DEPTH_ATTACHMENT_OPTIMAL: Self = Self(1000241000i32);
3586    pub const DEPTH_READ_ONLY_OPTIMAL: Self = Self(1000241001i32);
3587    pub const STENCIL_ATTACHMENT_OPTIMAL: Self = Self(1000241002i32);
3588    pub const STENCIL_READ_ONLY_OPTIMAL: Self = Self(1000241003i32);
3589    pub const READ_ONLY_OPTIMAL: Self = Self(1000314000i32);
3590    pub const ATTACHMENT_OPTIMAL: Self = Self(1000314001i32);
3591    pub const RENDERING_LOCAL_READ: Self = Self(1000232000i32);
3592    pub const PRESENT_SRC: Self = Self(1000001002i32);
3593    pub const VIDEO_DECODE_DST: Self = Self(1000024000i32);
3594    pub const VIDEO_DECODE_SRC: Self = Self(1000024001i32);
3595    pub const VIDEO_DECODE_DPB: Self = Self(1000024002i32);
3596    pub const SHARED_PRESENT: Self = Self(1000111000i32);
3597    pub const SHADING_RATE_OPTIMAL: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL;
3598    pub const FRAGMENT_DENSITY_MAP_OPTIMAL: Self = Self(1000218000i32);
3599    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL: Self = Self(1000164003i32);
3600    pub const VIDEO_ENCODE_DST: Self = Self(1000299000i32);
3601    pub const VIDEO_ENCODE_SRC: Self = Self(1000299001i32);
3602    pub const VIDEO_ENCODE_DPB: Self = Self(1000299002i32);
3603    pub const ATTACHMENT_FEEDBACK_LOOP_OPTIMAL: Self = Self(1000339000i32);
3604    pub const TENSOR_ALIASING: Self = Self(1000460000i32);
3605    pub const VIDEO_ENCODE_QUANTIZATION_MAP: Self = Self(1000553000i32);
3606    pub const ZERO_INITIALIZED: Self = Self(1000620000i32);
3607    #[inline]
3608    pub const fn from_raw(value: i32) -> Self {
3609        Self(value)
3610    }
3611    #[inline]
3612    pub const fn as_raw(self) -> i32 {
3613        self.0
3614    }
3615}
3616impl core::fmt::Debug for ImageLayout {
3617    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3618        match self.0 {
3619            0i32 => f.write_str("UNDEFINED"),
3620            1i32 => f.write_str("GENERAL"),
3621            2i32 => f.write_str("COLOR_ATTACHMENT_OPTIMAL"),
3622            3i32 => f.write_str("DEPTH_STENCIL_ATTACHMENT_OPTIMAL"),
3623            4i32 => f.write_str("DEPTH_STENCIL_READ_ONLY_OPTIMAL"),
3624            5i32 => f.write_str("SHADER_READ_ONLY_OPTIMAL"),
3625            6i32 => f.write_str("TRANSFER_SRC_OPTIMAL"),
3626            7i32 => f.write_str("TRANSFER_DST_OPTIMAL"),
3627            8i32 => f.write_str("PREINITIALIZED"),
3628            1000117000i32 => f.write_str("DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL"),
3629            1000117001i32 => f.write_str("DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL"),
3630            1000241000i32 => f.write_str("DEPTH_ATTACHMENT_OPTIMAL"),
3631            1000241001i32 => f.write_str("DEPTH_READ_ONLY_OPTIMAL"),
3632            1000241002i32 => f.write_str("STENCIL_ATTACHMENT_OPTIMAL"),
3633            1000241003i32 => f.write_str("STENCIL_READ_ONLY_OPTIMAL"),
3634            1000314000i32 => f.write_str("READ_ONLY_OPTIMAL"),
3635            1000314001i32 => f.write_str("ATTACHMENT_OPTIMAL"),
3636            1000232000i32 => f.write_str("RENDERING_LOCAL_READ"),
3637            1000001002i32 => f.write_str("PRESENT_SRC"),
3638            1000024000i32 => f.write_str("VIDEO_DECODE_DST"),
3639            1000024001i32 => f.write_str("VIDEO_DECODE_SRC"),
3640            1000024002i32 => f.write_str("VIDEO_DECODE_DPB"),
3641            1000111000i32 => f.write_str("SHARED_PRESENT"),
3642            1000218000i32 => f.write_str("FRAGMENT_DENSITY_MAP_OPTIMAL"),
3643            1000164003i32 => f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL"),
3644            1000299000i32 => f.write_str("VIDEO_ENCODE_DST"),
3645            1000299001i32 => f.write_str("VIDEO_ENCODE_SRC"),
3646            1000299002i32 => f.write_str("VIDEO_ENCODE_DPB"),
3647            1000339000i32 => f.write_str("ATTACHMENT_FEEDBACK_LOOP_OPTIMAL"),
3648            1000460000i32 => f.write_str("TENSOR_ALIASING"),
3649            1000553000i32 => f.write_str("VIDEO_ENCODE_QUANTIZATION_MAP"),
3650            1000620000i32 => f.write_str("ZERO_INITIALIZED"),
3651            other => write!(f, "{}({})", stringify!(ImageLayout), other),
3652        }
3653    }
3654}
3655impl core::fmt::Display for ImageLayout {
3656    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3657        core::fmt::Debug::fmt(self, f)
3658    }
3659}
3660impl core::error::Error for ImageLayout {}
3661///[`VkImageTiling`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageTiling.html)
3662#[repr(transparent)]
3663#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3664#[doc(alias = "VkImageTiling")]
3665pub struct ImageTiling(i32);
3666impl ImageTiling {
3667    pub const OPTIMAL: Self = Self(0i32);
3668    pub const LINEAR: Self = Self(1i32);
3669    pub const DRM_FORMAT_MODIFIER: Self = Self(1000158000i32);
3670    #[inline]
3671    pub const fn from_raw(value: i32) -> Self {
3672        Self(value)
3673    }
3674    #[inline]
3675    pub const fn as_raw(self) -> i32 {
3676        self.0
3677    }
3678}
3679impl core::fmt::Debug for ImageTiling {
3680    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3681        match self.0 {
3682            0i32 => f.write_str("OPTIMAL"),
3683            1i32 => f.write_str("LINEAR"),
3684            1000158000i32 => f.write_str("DRM_FORMAT_MODIFIER"),
3685            other => write!(f, "{}({})", stringify!(ImageTiling), other),
3686        }
3687    }
3688}
3689impl core::fmt::Display for ImageTiling {
3690    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3691        core::fmt::Debug::fmt(self, f)
3692    }
3693}
3694impl core::error::Error for ImageTiling {}
3695///[`VkImageType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageType.html)
3696#[repr(transparent)]
3697#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3698#[doc(alias = "VkImageType")]
3699pub struct ImageType(i32);
3700impl ImageType {
3701    pub const _1D: Self = Self(0i32);
3702    pub const _2D: Self = Self(1i32);
3703    pub const _3D: Self = Self(2i32);
3704    #[inline]
3705    pub const fn from_raw(value: i32) -> Self {
3706        Self(value)
3707    }
3708    #[inline]
3709    pub const fn as_raw(self) -> i32 {
3710        self.0
3711    }
3712}
3713impl core::fmt::Debug for ImageType {
3714    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3715        match self.0 {
3716            0i32 => f.write_str("_1D"),
3717            1i32 => f.write_str("_2D"),
3718            2i32 => f.write_str("_3D"),
3719            other => write!(f, "{}({})", stringify!(ImageType), other),
3720        }
3721    }
3722}
3723impl core::fmt::Display for ImageType {
3724    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3725        core::fmt::Debug::fmt(self, f)
3726    }
3727}
3728impl core::error::Error for ImageType {}
3729///[`VkImageViewType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewType.html)
3730#[repr(transparent)]
3731#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3732#[doc(alias = "VkImageViewType")]
3733pub struct ImageViewType(i32);
3734impl ImageViewType {
3735    pub const _1D: Self = Self(0i32);
3736    pub const _2D: Self = Self(1i32);
3737    pub const _3D: Self = Self(2i32);
3738    pub const CUBE: Self = Self(3i32);
3739    pub const _1D_ARRAY: Self = Self(4i32);
3740    pub const _2D_ARRAY: Self = Self(5i32);
3741    pub const CUBE_ARRAY: Self = Self(6i32);
3742    #[inline]
3743    pub const fn from_raw(value: i32) -> Self {
3744        Self(value)
3745    }
3746    #[inline]
3747    pub const fn as_raw(self) -> i32 {
3748        self.0
3749    }
3750}
3751impl core::fmt::Debug for ImageViewType {
3752    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3753        match self.0 {
3754            0i32 => f.write_str("_1D"),
3755            1i32 => f.write_str("_2D"),
3756            2i32 => f.write_str("_3D"),
3757            3i32 => f.write_str("CUBE"),
3758            4i32 => f.write_str("_1D_ARRAY"),
3759            5i32 => f.write_str("_2D_ARRAY"),
3760            6i32 => f.write_str("CUBE_ARRAY"),
3761            other => write!(f, "{}({})", stringify!(ImageViewType), other),
3762        }
3763    }
3764}
3765impl core::fmt::Display for ImageViewType {
3766    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3767        core::fmt::Debug::fmt(self, f)
3768    }
3769}
3770impl core::error::Error for ImageViewType {}
3771///[`VkIndexType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndexType.html)
3772#[repr(transparent)]
3773#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3774#[doc(alias = "VkIndexType")]
3775pub struct IndexType(i32);
3776impl IndexType {
3777    pub const UINT16: Self = Self(0i32);
3778    pub const UINT32: Self = Self(1i32);
3779    pub const UINT8: Self = Self(1000265000i32);
3780    pub const NONE: Self = Self(1000165000i32);
3781    #[inline]
3782    pub const fn from_raw(value: i32) -> Self {
3783        Self(value)
3784    }
3785    #[inline]
3786    pub const fn as_raw(self) -> i32 {
3787        self.0
3788    }
3789}
3790impl core::fmt::Debug for IndexType {
3791    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3792        match self.0 {
3793            0i32 => f.write_str("UINT16"),
3794            1i32 => f.write_str("UINT32"),
3795            1000265000i32 => f.write_str("UINT8"),
3796            1000165000i32 => f.write_str("NONE"),
3797            other => write!(f, "{}({})", stringify!(IndexType), other),
3798        }
3799    }
3800}
3801impl core::fmt::Display for IndexType {
3802    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3803        core::fmt::Debug::fmt(self, f)
3804    }
3805}
3806impl core::error::Error for IndexType {}
3807///[`VkIndirectCommandsTokenTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsTokenTypeEXT.html)
3808#[repr(transparent)]
3809#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3810#[doc(alias = "VkIndirectCommandsTokenTypeEXT")]
3811pub struct IndirectCommandsTokenTypeEXT(i32);
3812impl IndirectCommandsTokenTypeEXT {
3813    pub const EXECUTION_SET: Self = Self(0i32);
3814    pub const PUSH_CONSTANT: Self = Self(1i32);
3815    pub const SEQUENCE_INDEX: Self = Self(2i32);
3816    pub const INDEX_BUFFER: Self = Self(3i32);
3817    pub const VERTEX_BUFFER: Self = Self(4i32);
3818    pub const DRAW_INDEXED: Self = Self(5i32);
3819    pub const DRAW: Self = Self(6i32);
3820    pub const DRAW_INDEXED_COUNT: Self = Self(7i32);
3821    pub const DRAW_COUNT: Self = Self(8i32);
3822    pub const DISPATCH: Self = Self(9i32);
3823    pub const PUSH_DATA: Self = Self(1000135000i32);
3824    pub const PUSH_DATA_SEQUENCE_INDEX: Self = Self(1000135001i32);
3825    pub const DRAW_MESH_TASKS_: Self = Self(1000202002i32);
3826    pub const DRAW_MESH_TASKS_COUNT_: Self = Self(1000202003i32);
3827    pub const DRAW_MESH_TASKS: Self = Self(1000328000i32);
3828    pub const DRAW_MESH_TASKS_COUNT: Self = Self(1000328001i32);
3829    pub const TRACE_RAYS2: Self = Self(1000386004i32);
3830    #[inline]
3831    pub const fn from_raw(value: i32) -> Self {
3832        Self(value)
3833    }
3834    #[inline]
3835    pub const fn as_raw(self) -> i32 {
3836        self.0
3837    }
3838}
3839impl core::fmt::Debug for IndirectCommandsTokenTypeEXT {
3840    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3841        match self.0 {
3842            0i32 => f.write_str("EXECUTION_SET"),
3843            1i32 => f.write_str("PUSH_CONSTANT"),
3844            2i32 => f.write_str("SEQUENCE_INDEX"),
3845            3i32 => f.write_str("INDEX_BUFFER"),
3846            4i32 => f.write_str("VERTEX_BUFFER"),
3847            5i32 => f.write_str("DRAW_INDEXED"),
3848            6i32 => f.write_str("DRAW"),
3849            7i32 => f.write_str("DRAW_INDEXED_COUNT"),
3850            8i32 => f.write_str("DRAW_COUNT"),
3851            9i32 => f.write_str("DISPATCH"),
3852            1000135000i32 => f.write_str("PUSH_DATA"),
3853            1000135001i32 => f.write_str("PUSH_DATA_SEQUENCE_INDEX"),
3854            1000202002i32 => f.write_str("DRAW_MESH_TASKS_"),
3855            1000202003i32 => f.write_str("DRAW_MESH_TASKS_COUNT_"),
3856            1000328000i32 => f.write_str("DRAW_MESH_TASKS"),
3857            1000328001i32 => f.write_str("DRAW_MESH_TASKS_COUNT"),
3858            1000386004i32 => f.write_str("TRACE_RAYS2"),
3859            other => write!(f, "{}({})", stringify!(IndirectCommandsTokenTypeEXT), other),
3860        }
3861    }
3862}
3863impl core::fmt::Display for IndirectCommandsTokenTypeEXT {
3864    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3865        core::fmt::Debug::fmt(self, f)
3866    }
3867}
3868impl core::error::Error for IndirectCommandsTokenTypeEXT {}
3869///[`VkIndirectCommandsTokenTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsTokenTypeNV.html)
3870#[repr(transparent)]
3871#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3872#[doc(alias = "VkIndirectCommandsTokenTypeNV")]
3873pub struct IndirectCommandsTokenTypeNV(i32);
3874impl IndirectCommandsTokenTypeNV {
3875    pub const SHADER_GROUP: Self = Self(0i32);
3876    pub const STATE_FLAGS: Self = Self(1i32);
3877    pub const INDEX_BUFFER: Self = Self(2i32);
3878    pub const VERTEX_BUFFER: Self = Self(3i32);
3879    pub const PUSH_CONSTANT: Self = Self(4i32);
3880    pub const DRAW_INDEXED: Self = Self(5i32);
3881    pub const DRAW: Self = Self(6i32);
3882    pub const DRAW_TASKS: Self = Self(7i32);
3883    pub const PUSH_DATA: Self = Self(1000135000i32);
3884    pub const DRAW_MESH_TASKS: Self = Self(1000328000i32);
3885    pub const PIPELINE: Self = Self(1000428003i32);
3886    pub const DISPATCH: Self = Self(1000428004i32);
3887    #[inline]
3888    pub const fn from_raw(value: i32) -> Self {
3889        Self(value)
3890    }
3891    #[inline]
3892    pub const fn as_raw(self) -> i32 {
3893        self.0
3894    }
3895}
3896impl core::fmt::Debug for IndirectCommandsTokenTypeNV {
3897    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3898        match self.0 {
3899            0i32 => f.write_str("SHADER_GROUP"),
3900            1i32 => f.write_str("STATE_FLAGS"),
3901            2i32 => f.write_str("INDEX_BUFFER"),
3902            3i32 => f.write_str("VERTEX_BUFFER"),
3903            4i32 => f.write_str("PUSH_CONSTANT"),
3904            5i32 => f.write_str("DRAW_INDEXED"),
3905            6i32 => f.write_str("DRAW"),
3906            7i32 => f.write_str("DRAW_TASKS"),
3907            1000135000i32 => f.write_str("PUSH_DATA"),
3908            1000328000i32 => f.write_str("DRAW_MESH_TASKS"),
3909            1000428003i32 => f.write_str("PIPELINE"),
3910            1000428004i32 => f.write_str("DISPATCH"),
3911            other => write!(f, "{}({})", stringify!(IndirectCommandsTokenTypeNV), other),
3912        }
3913    }
3914}
3915impl core::fmt::Display for IndirectCommandsTokenTypeNV {
3916    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3917        core::fmt::Debug::fmt(self, f)
3918    }
3919}
3920impl core::error::Error for IndirectCommandsTokenTypeNV {}
3921///[`VkIndirectExecutionSetInfoTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetInfoTypeEXT.html)
3922#[repr(transparent)]
3923#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3924#[doc(alias = "VkIndirectExecutionSetInfoTypeEXT")]
3925pub struct IndirectExecutionSetInfoTypeEXT(i32);
3926impl IndirectExecutionSetInfoTypeEXT {
3927    pub const PIPELINES: Self = Self(0i32);
3928    pub const SHADER_OBJECTS: Self = Self(1i32);
3929    #[inline]
3930    pub const fn from_raw(value: i32) -> Self {
3931        Self(value)
3932    }
3933    #[inline]
3934    pub const fn as_raw(self) -> i32 {
3935        self.0
3936    }
3937}
3938impl core::fmt::Debug for IndirectExecutionSetInfoTypeEXT {
3939    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3940        match self.0 {
3941            0i32 => f.write_str("PIPELINES"),
3942            1i32 => f.write_str("SHADER_OBJECTS"),
3943            other => {
3944                write!(f, "{}({})", stringify!(IndirectExecutionSetInfoTypeEXT), other)
3945            }
3946        }
3947    }
3948}
3949impl core::fmt::Display for IndirectExecutionSetInfoTypeEXT {
3950    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3951        core::fmt::Debug::fmt(self, f)
3952    }
3953}
3954impl core::error::Error for IndirectExecutionSetInfoTypeEXT {}
3955///[`VkInternalAllocationType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkInternalAllocationType.html)
3956#[repr(transparent)]
3957#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3958#[doc(alias = "VkInternalAllocationType")]
3959pub struct InternalAllocationType(i32);
3960impl InternalAllocationType {
3961    pub const EXECUTABLE: Self = Self(0i32);
3962    #[inline]
3963    pub const fn from_raw(value: i32) -> Self {
3964        Self(value)
3965    }
3966    #[inline]
3967    pub const fn as_raw(self) -> i32 {
3968        self.0
3969    }
3970}
3971impl core::fmt::Debug for InternalAllocationType {
3972    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3973        match self.0 {
3974            0i32 => f.write_str("EXECUTABLE"),
3975            other => write!(f, "{}({})", stringify!(InternalAllocationType), other),
3976        }
3977    }
3978}
3979impl core::fmt::Display for InternalAllocationType {
3980    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
3981        core::fmt::Debug::fmt(self, f)
3982    }
3983}
3984impl core::error::Error for InternalAllocationType {}
3985///[`VkLatencyMarkerNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencyMarkerNV.html)
3986#[repr(transparent)]
3987#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
3988#[doc(alias = "VkLatencyMarkerNV")]
3989pub struct LatencyMarkerNV(i32);
3990impl LatencyMarkerNV {
3991    pub const SIMULATION_START: Self = Self(0i32);
3992    pub const SIMULATION_END: Self = Self(1i32);
3993    pub const RENDERSUBMIT_START: Self = Self(2i32);
3994    pub const RENDERSUBMIT_END: Self = Self(3i32);
3995    pub const PRESENT_START: Self = Self(4i32);
3996    pub const PRESENT_END: Self = Self(5i32);
3997    pub const INPUT_SAMPLE: Self = Self(6i32);
3998    pub const TRIGGER_FLASH: Self = Self(7i32);
3999    pub const OUT_OF_BAND_RENDERSUBMIT_START: Self = Self(8i32);
4000    pub const OUT_OF_BAND_RENDERSUBMIT_END: Self = Self(9i32);
4001    pub const OUT_OF_BAND_PRESENT_START: Self = Self(10i32);
4002    pub const OUT_OF_BAND_PRESENT_END: Self = Self(11i32);
4003    #[inline]
4004    pub const fn from_raw(value: i32) -> Self {
4005        Self(value)
4006    }
4007    #[inline]
4008    pub const fn as_raw(self) -> i32 {
4009        self.0
4010    }
4011}
4012impl core::fmt::Debug for LatencyMarkerNV {
4013    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4014        match self.0 {
4015            0i32 => f.write_str("SIMULATION_START"),
4016            1i32 => f.write_str("SIMULATION_END"),
4017            2i32 => f.write_str("RENDERSUBMIT_START"),
4018            3i32 => f.write_str("RENDERSUBMIT_END"),
4019            4i32 => f.write_str("PRESENT_START"),
4020            5i32 => f.write_str("PRESENT_END"),
4021            6i32 => f.write_str("INPUT_SAMPLE"),
4022            7i32 => f.write_str("TRIGGER_FLASH"),
4023            8i32 => f.write_str("OUT_OF_BAND_RENDERSUBMIT_START"),
4024            9i32 => f.write_str("OUT_OF_BAND_RENDERSUBMIT_END"),
4025            10i32 => f.write_str("OUT_OF_BAND_PRESENT_START"),
4026            11i32 => f.write_str("OUT_OF_BAND_PRESENT_END"),
4027            other => write!(f, "{}({})", stringify!(LatencyMarkerNV), other),
4028        }
4029    }
4030}
4031impl core::fmt::Display for LatencyMarkerNV {
4032    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4033        core::fmt::Debug::fmt(self, f)
4034    }
4035}
4036impl core::error::Error for LatencyMarkerNV {}
4037///[`VkLayerSettingTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayerSettingTypeEXT.html)
4038#[repr(transparent)]
4039#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4040#[doc(alias = "VkLayerSettingTypeEXT")]
4041pub struct LayerSettingTypeEXT(i32);
4042impl LayerSettingTypeEXT {
4043    pub const BOOL32: Self = Self(0i32);
4044    pub const INT32: Self = Self(1i32);
4045    pub const INT64: Self = Self(2i32);
4046    pub const UINT32: Self = Self(3i32);
4047    pub const UINT64: Self = Self(4i32);
4048    pub const FLOAT32: Self = Self(5i32);
4049    pub const FLOAT64: Self = Self(6i32);
4050    pub const STRING: Self = Self(7i32);
4051    #[inline]
4052    pub const fn from_raw(value: i32) -> Self {
4053        Self(value)
4054    }
4055    #[inline]
4056    pub const fn as_raw(self) -> i32 {
4057        self.0
4058    }
4059}
4060impl core::fmt::Debug for LayerSettingTypeEXT {
4061    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4062        match self.0 {
4063            0i32 => f.write_str("BOOL32"),
4064            1i32 => f.write_str("INT32"),
4065            2i32 => f.write_str("INT64"),
4066            3i32 => f.write_str("UINT32"),
4067            4i32 => f.write_str("UINT64"),
4068            5i32 => f.write_str("FLOAT32"),
4069            6i32 => f.write_str("FLOAT64"),
4070            7i32 => f.write_str("STRING"),
4071            other => write!(f, "{}({})", stringify!(LayerSettingTypeEXT), other),
4072        }
4073    }
4074}
4075impl core::fmt::Display for LayerSettingTypeEXT {
4076    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4077        core::fmt::Debug::fmt(self, f)
4078    }
4079}
4080impl core::error::Error for LayerSettingTypeEXT {}
4081///[`VkLayeredDriverUnderlyingApiMSFT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayeredDriverUnderlyingApiMSFT.html)
4082#[repr(transparent)]
4083#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4084#[doc(alias = "VkLayeredDriverUnderlyingApiMSFT")]
4085pub struct LayeredDriverUnderlyingApiMSFT(i32);
4086impl LayeredDriverUnderlyingApiMSFT {
4087    pub const NONE: Self = Self(0i32);
4088    pub const D3D12: Self = Self(1i32);
4089    #[inline]
4090    pub const fn from_raw(value: i32) -> Self {
4091        Self(value)
4092    }
4093    #[inline]
4094    pub const fn as_raw(self) -> i32 {
4095        self.0
4096    }
4097}
4098impl core::fmt::Debug for LayeredDriverUnderlyingApiMSFT {
4099    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4100        match self.0 {
4101            0i32 => f.write_str("NONE"),
4102            1i32 => f.write_str("D3D12"),
4103            other => {
4104                write!(f, "{}({})", stringify!(LayeredDriverUnderlyingApiMSFT), other)
4105            }
4106        }
4107    }
4108}
4109impl core::fmt::Display for LayeredDriverUnderlyingApiMSFT {
4110    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4111        core::fmt::Debug::fmt(self, f)
4112    }
4113}
4114impl core::error::Error for LayeredDriverUnderlyingApiMSFT {}
4115///[`VkLineRasterizationMode`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkLineRasterizationMode.html)
4116#[repr(transparent)]
4117#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4118#[doc(alias = "VkLineRasterizationMode")]
4119pub struct LineRasterizationMode(i32);
4120impl LineRasterizationMode {
4121    pub const DEFAULT: Self = Self(0i32);
4122    pub const RECTANGULAR: Self = Self(1i32);
4123    pub const BRESENHAM: Self = Self(2i32);
4124    pub const RECTANGULAR_SMOOTH: Self = Self(3i32);
4125    #[inline]
4126    pub const fn from_raw(value: i32) -> Self {
4127        Self(value)
4128    }
4129    #[inline]
4130    pub const fn as_raw(self) -> i32 {
4131        self.0
4132    }
4133}
4134impl core::fmt::Debug for LineRasterizationMode {
4135    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4136        match self.0 {
4137            0i32 => f.write_str("DEFAULT"),
4138            1i32 => f.write_str("RECTANGULAR"),
4139            2i32 => f.write_str("BRESENHAM"),
4140            3i32 => f.write_str("RECTANGULAR_SMOOTH"),
4141            other => write!(f, "{}({})", stringify!(LineRasterizationMode), other),
4142        }
4143    }
4144}
4145impl core::fmt::Display for LineRasterizationMode {
4146    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4147        core::fmt::Debug::fmt(self, f)
4148    }
4149}
4150impl core::error::Error for LineRasterizationMode {}
4151///[`VkLogicOp`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkLogicOp.html)
4152#[repr(transparent)]
4153#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4154#[doc(alias = "VkLogicOp")]
4155pub struct LogicOp(i32);
4156impl LogicOp {
4157    pub const CLEAR: Self = Self(0i32);
4158    pub const AND: Self = Self(1i32);
4159    pub const AND_REVERSE: Self = Self(2i32);
4160    pub const COPY: Self = Self(3i32);
4161    pub const AND_INVERTED: Self = Self(4i32);
4162    pub const NO_OP: Self = Self(5i32);
4163    pub const XOR: Self = Self(6i32);
4164    pub const OR: Self = Self(7i32);
4165    pub const NOR: Self = Self(8i32);
4166    pub const EQUIVALENT: Self = Self(9i32);
4167    pub const INVERT: Self = Self(10i32);
4168    pub const OR_REVERSE: Self = Self(11i32);
4169    pub const COPY_INVERTED: Self = Self(12i32);
4170    pub const OR_INVERTED: Self = Self(13i32);
4171    pub const NAND: Self = Self(14i32);
4172    pub const SET: Self = Self(15i32);
4173    #[inline]
4174    pub const fn from_raw(value: i32) -> Self {
4175        Self(value)
4176    }
4177    #[inline]
4178    pub const fn as_raw(self) -> i32 {
4179        self.0
4180    }
4181}
4182impl core::fmt::Debug for LogicOp {
4183    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4184        match self.0 {
4185            0i32 => f.write_str("CLEAR"),
4186            1i32 => f.write_str("AND"),
4187            2i32 => f.write_str("AND_REVERSE"),
4188            3i32 => f.write_str("COPY"),
4189            4i32 => f.write_str("AND_INVERTED"),
4190            5i32 => f.write_str("NO_OP"),
4191            6i32 => f.write_str("XOR"),
4192            7i32 => f.write_str("OR"),
4193            8i32 => f.write_str("NOR"),
4194            9i32 => f.write_str("EQUIVALENT"),
4195            10i32 => f.write_str("INVERT"),
4196            11i32 => f.write_str("OR_REVERSE"),
4197            12i32 => f.write_str("COPY_INVERTED"),
4198            13i32 => f.write_str("OR_INVERTED"),
4199            14i32 => f.write_str("NAND"),
4200            15i32 => f.write_str("SET"),
4201            other => write!(f, "{}({})", stringify!(LogicOp), other),
4202        }
4203    }
4204}
4205impl core::fmt::Display for LogicOp {
4206    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4207        core::fmt::Debug::fmt(self, f)
4208    }
4209}
4210impl core::error::Error for LogicOp {}
4211///[`VkMemoryOverallocationBehaviorAMD`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryOverallocationBehaviorAMD.html)
4212#[repr(transparent)]
4213#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4214#[doc(alias = "VkMemoryOverallocationBehaviorAMD")]
4215pub struct MemoryOverallocationBehaviorAMD(i32);
4216impl MemoryOverallocationBehaviorAMD {
4217    pub const DEFAULT: Self = Self(0i32);
4218    pub const ALLOWED: Self = Self(1i32);
4219    pub const DISALLOWED: Self = Self(2i32);
4220    #[inline]
4221    pub const fn from_raw(value: i32) -> Self {
4222        Self(value)
4223    }
4224    #[inline]
4225    pub const fn as_raw(self) -> i32 {
4226        self.0
4227    }
4228}
4229impl core::fmt::Debug for MemoryOverallocationBehaviorAMD {
4230    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4231        match self.0 {
4232            0i32 => f.write_str("DEFAULT"),
4233            1i32 => f.write_str("ALLOWED"),
4234            2i32 => f.write_str("DISALLOWED"),
4235            other => {
4236                write!(f, "{}({})", stringify!(MemoryOverallocationBehaviorAMD), other)
4237            }
4238        }
4239    }
4240}
4241impl core::fmt::Display for MemoryOverallocationBehaviorAMD {
4242    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4243        core::fmt::Debug::fmt(self, f)
4244    }
4245}
4246impl core::error::Error for MemoryOverallocationBehaviorAMD {}
4247///[`VkMicromapTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapTypeEXT.html)
4248#[repr(transparent)]
4249#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4250#[doc(alias = "VkMicromapTypeEXT")]
4251pub struct MicromapTypeEXT(i32);
4252impl MicromapTypeEXT {
4253    pub const OPACITY_MICROMAP: Self = Self(0i32);
4254    pub const DISPLACEMENT_MICROMAP: Self = Self(1000397000i32);
4255    #[inline]
4256    pub const fn from_raw(value: i32) -> Self {
4257        Self(value)
4258    }
4259    #[inline]
4260    pub const fn as_raw(self) -> i32 {
4261        self.0
4262    }
4263}
4264impl core::fmt::Debug for MicromapTypeEXT {
4265    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4266        match self.0 {
4267            0i32 => f.write_str("OPACITY_MICROMAP"),
4268            1000397000i32 => f.write_str("DISPLACEMENT_MICROMAP"),
4269            other => write!(f, "{}({})", stringify!(MicromapTypeEXT), other),
4270        }
4271    }
4272}
4273impl core::fmt::Display for MicromapTypeEXT {
4274    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4275        core::fmt::Debug::fmt(self, f)
4276    }
4277}
4278impl core::error::Error for MicromapTypeEXT {}
4279///[`VkObjectType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkObjectType.html)
4280#[repr(transparent)]
4281#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4282#[doc(alias = "VkObjectType")]
4283pub struct ObjectType(i32);
4284impl ObjectType {
4285    pub const UNKNOWN: Self = Self(0i32);
4286    pub const INSTANCE: Self = Self(1i32);
4287    pub const PHYSICAL_DEVICE: Self = Self(2i32);
4288    pub const DEVICE: Self = Self(3i32);
4289    pub const QUEUE: Self = Self(4i32);
4290    pub const SEMAPHORE: Self = Self(5i32);
4291    pub const COMMAND_BUFFER: Self = Self(6i32);
4292    pub const FENCE: Self = Self(7i32);
4293    pub const DEVICE_MEMORY: Self = Self(8i32);
4294    pub const BUFFER: Self = Self(9i32);
4295    pub const IMAGE: Self = Self(10i32);
4296    pub const EVENT: Self = Self(11i32);
4297    pub const QUERY_POOL: Self = Self(12i32);
4298    pub const BUFFER_VIEW: Self = Self(13i32);
4299    pub const IMAGE_VIEW: Self = Self(14i32);
4300    pub const SHADER_MODULE: Self = Self(15i32);
4301    pub const PIPELINE_CACHE: Self = Self(16i32);
4302    pub const PIPELINE_LAYOUT: Self = Self(17i32);
4303    pub const RENDER_PASS: Self = Self(18i32);
4304    pub const PIPELINE: Self = Self(19i32);
4305    pub const DESCRIPTOR_SET_LAYOUT: Self = Self(20i32);
4306    pub const SAMPLER: Self = Self(21i32);
4307    pub const DESCRIPTOR_POOL: Self = Self(22i32);
4308    pub const DESCRIPTOR_SET: Self = Self(23i32);
4309    pub const FRAMEBUFFER: Self = Self(24i32);
4310    pub const COMMAND_POOL: Self = Self(25i32);
4311    pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1000085000i32);
4312    pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1000156000i32);
4313    pub const PRIVATE_DATA_SLOT: Self = Self(1000295000i32);
4314    pub const SURFACE: Self = Self(1000000000i32);
4315    pub const SWAPCHAIN: Self = Self(1000001000i32);
4316    pub const DISPLAY: Self = Self(1000002000i32);
4317    pub const DISPLAY_MODE: Self = Self(1000002001i32);
4318    pub const DEBUG_REPORT_CALLBACK: Self = Self(1000011000i32);
4319    ///VkVideoSessionKHR
4320    pub const VIDEO_SESSION: Self = Self(1000023000i32);
4321    ///VkVideoSessionParametersKHR
4322    pub const VIDEO_SESSION_PARAMETERS: Self = Self(1000023001i32);
4323    pub const CU_MODULE: Self = Self(1000029000i32);
4324    pub const CU_FUNCTION: Self = Self(1000029001i32);
4325    pub const DEBUG_UTILS_MESSENGER: Self = Self(1000128000i32);
4326    pub const ACCELERATION_STRUCTURE: Self = Self(1000150000i32);
4327    pub const VALIDATION_CACHE: Self = Self(1000160000i32);
4328    pub const PERFORMANCE_CONFIGURATION: Self = Self(1000210000i32);
4329    pub const DEFERRED_OPERATION: Self = Self(1000268000i32);
4330    pub const INDIRECT_COMMANDS_LAYOUT: Self = Self(1000277000i32);
4331    pub const CUDA_MODULE: Self = Self(1000307000i32);
4332    pub const CUDA_FUNCTION: Self = Self(1000307001i32);
4333    ///VkBufferCollectionFUCHSIA
4334    pub const BUFFER_COLLECTION: Self = Self(1000366000i32);
4335    pub const MICROMAP: Self = Self(1000396000i32);
4336    pub const TENSOR: Self = Self(1000460000i32);
4337    pub const TENSOR_VIEW: Self = Self(1000460001i32);
4338    pub const OPTICAL_FLOW_SESSION: Self = Self(1000464000i32);
4339    pub const SHADER: Self = Self(1000482000i32);
4340    pub const PIPELINE_BINARY: Self = Self(1000483000i32);
4341    pub const DATA_GRAPH_PIPELINE_SESSION: Self = Self(1000507000i32);
4342    pub const EXTERNAL_COMPUTE_QUEUE: Self = Self(1000556000i32);
4343    pub const INDIRECT_EXECUTION_SET: Self = Self(1000572001i32);
4344    pub const SHADER_INSTRUMENTATION: Self = Self(1000607000i32);
4345    #[inline]
4346    pub const fn from_raw(value: i32) -> Self {
4347        Self(value)
4348    }
4349    #[inline]
4350    pub const fn as_raw(self) -> i32 {
4351        self.0
4352    }
4353}
4354impl core::fmt::Debug for ObjectType {
4355    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4356        match self.0 {
4357            0i32 => f.write_str("UNKNOWN"),
4358            1i32 => f.write_str("INSTANCE"),
4359            2i32 => f.write_str("PHYSICAL_DEVICE"),
4360            3i32 => f.write_str("DEVICE"),
4361            4i32 => f.write_str("QUEUE"),
4362            5i32 => f.write_str("SEMAPHORE"),
4363            6i32 => f.write_str("COMMAND_BUFFER"),
4364            7i32 => f.write_str("FENCE"),
4365            8i32 => f.write_str("DEVICE_MEMORY"),
4366            9i32 => f.write_str("BUFFER"),
4367            10i32 => f.write_str("IMAGE"),
4368            11i32 => f.write_str("EVENT"),
4369            12i32 => f.write_str("QUERY_POOL"),
4370            13i32 => f.write_str("BUFFER_VIEW"),
4371            14i32 => f.write_str("IMAGE_VIEW"),
4372            15i32 => f.write_str("SHADER_MODULE"),
4373            16i32 => f.write_str("PIPELINE_CACHE"),
4374            17i32 => f.write_str("PIPELINE_LAYOUT"),
4375            18i32 => f.write_str("RENDER_PASS"),
4376            19i32 => f.write_str("PIPELINE"),
4377            20i32 => f.write_str("DESCRIPTOR_SET_LAYOUT"),
4378            21i32 => f.write_str("SAMPLER"),
4379            22i32 => f.write_str("DESCRIPTOR_POOL"),
4380            23i32 => f.write_str("DESCRIPTOR_SET"),
4381            24i32 => f.write_str("FRAMEBUFFER"),
4382            25i32 => f.write_str("COMMAND_POOL"),
4383            1000085000i32 => f.write_str("DESCRIPTOR_UPDATE_TEMPLATE"),
4384            1000156000i32 => f.write_str("SAMPLER_YCBCR_CONVERSION"),
4385            1000295000i32 => f.write_str("PRIVATE_DATA_SLOT"),
4386            1000000000i32 => f.write_str("SURFACE"),
4387            1000001000i32 => f.write_str("SWAPCHAIN"),
4388            1000002000i32 => f.write_str("DISPLAY"),
4389            1000002001i32 => f.write_str("DISPLAY_MODE"),
4390            1000011000i32 => f.write_str("DEBUG_REPORT_CALLBACK"),
4391            1000023000i32 => f.write_str("VIDEO_SESSION"),
4392            1000023001i32 => f.write_str("VIDEO_SESSION_PARAMETERS"),
4393            1000029000i32 => f.write_str("CU_MODULE"),
4394            1000029001i32 => f.write_str("CU_FUNCTION"),
4395            1000128000i32 => f.write_str("DEBUG_UTILS_MESSENGER"),
4396            1000150000i32 => f.write_str("ACCELERATION_STRUCTURE"),
4397            1000160000i32 => f.write_str("VALIDATION_CACHE"),
4398            1000210000i32 => f.write_str("PERFORMANCE_CONFIGURATION"),
4399            1000268000i32 => f.write_str("DEFERRED_OPERATION"),
4400            1000277000i32 => f.write_str("INDIRECT_COMMANDS_LAYOUT"),
4401            1000307000i32 => f.write_str("CUDA_MODULE"),
4402            1000307001i32 => f.write_str("CUDA_FUNCTION"),
4403            1000366000i32 => f.write_str("BUFFER_COLLECTION"),
4404            1000396000i32 => f.write_str("MICROMAP"),
4405            1000460000i32 => f.write_str("TENSOR"),
4406            1000460001i32 => f.write_str("TENSOR_VIEW"),
4407            1000464000i32 => f.write_str("OPTICAL_FLOW_SESSION"),
4408            1000482000i32 => f.write_str("SHADER"),
4409            1000483000i32 => f.write_str("PIPELINE_BINARY"),
4410            1000507000i32 => f.write_str("DATA_GRAPH_PIPELINE_SESSION"),
4411            1000556000i32 => f.write_str("EXTERNAL_COMPUTE_QUEUE"),
4412            1000572001i32 => f.write_str("INDIRECT_EXECUTION_SET"),
4413            1000607000i32 => f.write_str("SHADER_INSTRUMENTATION"),
4414            other => write!(f, "{}({})", stringify!(ObjectType), other),
4415        }
4416    }
4417}
4418impl core::fmt::Display for ObjectType {
4419    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4420        core::fmt::Debug::fmt(self, f)
4421    }
4422}
4423impl core::error::Error for ObjectType {}
4424///[`VkOpacityMicromapFormatEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapFormatEXT.html)
4425#[repr(transparent)]
4426#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4427#[doc(alias = "VkOpacityMicromapFormatEXT")]
4428pub struct OpacityMicromapFormatEXT(i32);
4429impl OpacityMicromapFormatEXT {
4430    pub const _2_STATE: Self = Self(1i32);
4431    pub const _4_STATE: Self = Self(2i32);
4432    #[inline]
4433    pub const fn from_raw(value: i32) -> Self {
4434        Self(value)
4435    }
4436    #[inline]
4437    pub const fn as_raw(self) -> i32 {
4438        self.0
4439    }
4440}
4441impl core::fmt::Debug for OpacityMicromapFormatEXT {
4442    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4443        match self.0 {
4444            1i32 => f.write_str("_2_STATE"),
4445            2i32 => f.write_str("_4_STATE"),
4446            other => write!(f, "{}({})", stringify!(OpacityMicromapFormatEXT), other),
4447        }
4448    }
4449}
4450impl core::fmt::Display for OpacityMicromapFormatEXT {
4451    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4452        core::fmt::Debug::fmt(self, f)
4453    }
4454}
4455impl core::error::Error for OpacityMicromapFormatEXT {}
4456///[`VkOpacityMicromapSpecialIndexEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapSpecialIndexEXT.html)
4457#[repr(transparent)]
4458#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4459#[doc(alias = "VkOpacityMicromapSpecialIndexEXT")]
4460pub struct OpacityMicromapSpecialIndexEXT(i32);
4461impl OpacityMicromapSpecialIndexEXT {
4462    pub const FULLY_TRANSPARENT: Self = Self(-1i32);
4463    pub const FULLY_OPAQUE: Self = Self(-2i32);
4464    pub const FULLY_UNKNOWN_TRANSPARENT: Self = Self(-3i32);
4465    pub const FULLY_UNKNOWN_OPAQUE: Self = Self(-4i32);
4466    pub const CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP: Self = Self(-5i32);
4467    #[inline]
4468    pub const fn from_raw(value: i32) -> Self {
4469        Self(value)
4470    }
4471    #[inline]
4472    pub const fn as_raw(self) -> i32 {
4473        self.0
4474    }
4475}
4476impl core::fmt::Debug for OpacityMicromapSpecialIndexEXT {
4477    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4478        match self.0 {
4479            -1i32 => f.write_str("FULLY_TRANSPARENT"),
4480            -2i32 => f.write_str("FULLY_OPAQUE"),
4481            -3i32 => f.write_str("FULLY_UNKNOWN_TRANSPARENT"),
4482            -4i32 => f.write_str("FULLY_UNKNOWN_OPAQUE"),
4483            -5i32 => f.write_str("CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP"),
4484            other => {
4485                write!(f, "{}({})", stringify!(OpacityMicromapSpecialIndexEXT), other)
4486            }
4487        }
4488    }
4489}
4490impl core::fmt::Display for OpacityMicromapSpecialIndexEXT {
4491    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4492        core::fmt::Debug::fmt(self, f)
4493    }
4494}
4495impl core::error::Error for OpacityMicromapSpecialIndexEXT {}
4496///[`VkOpticalFlowPerformanceLevelNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowPerformanceLevelNV.html)
4497#[repr(transparent)]
4498#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4499#[doc(alias = "VkOpticalFlowPerformanceLevelNV")]
4500pub struct OpticalFlowPerformanceLevelNV(i32);
4501impl OpticalFlowPerformanceLevelNV {
4502    pub const UNKNOWN: Self = Self(0i32);
4503    pub const SLOW: Self = Self(1i32);
4504    pub const MEDIUM: Self = Self(2i32);
4505    pub const FAST: Self = Self(3i32);
4506    #[inline]
4507    pub const fn from_raw(value: i32) -> Self {
4508        Self(value)
4509    }
4510    #[inline]
4511    pub const fn as_raw(self) -> i32 {
4512        self.0
4513    }
4514}
4515impl core::fmt::Debug for OpticalFlowPerformanceLevelNV {
4516    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4517        match self.0 {
4518            0i32 => f.write_str("UNKNOWN"),
4519            1i32 => f.write_str("SLOW"),
4520            2i32 => f.write_str("MEDIUM"),
4521            3i32 => f.write_str("FAST"),
4522            other => {
4523                write!(f, "{}({})", stringify!(OpticalFlowPerformanceLevelNV), other)
4524            }
4525        }
4526    }
4527}
4528impl core::fmt::Display for OpticalFlowPerformanceLevelNV {
4529    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4530        core::fmt::Debug::fmt(self, f)
4531    }
4532}
4533impl core::error::Error for OpticalFlowPerformanceLevelNV {}
4534///[`VkOpticalFlowSessionBindingPointNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionBindingPointNV.html)
4535#[repr(transparent)]
4536#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4537#[doc(alias = "VkOpticalFlowSessionBindingPointNV")]
4538pub struct OpticalFlowSessionBindingPointNV(i32);
4539impl OpticalFlowSessionBindingPointNV {
4540    pub const UNKNOWN: Self = Self(0i32);
4541    pub const INPUT: Self = Self(1i32);
4542    pub const REFERENCE: Self = Self(2i32);
4543    pub const HINT: Self = Self(3i32);
4544    pub const FLOW_VECTOR: Self = Self(4i32);
4545    pub const BACKWARD_FLOW_VECTOR: Self = Self(5i32);
4546    pub const COST: Self = Self(6i32);
4547    pub const BACKWARD_COST: Self = Self(7i32);
4548    pub const GLOBAL_FLOW: Self = Self(8i32);
4549    #[inline]
4550    pub const fn from_raw(value: i32) -> Self {
4551        Self(value)
4552    }
4553    #[inline]
4554    pub const fn as_raw(self) -> i32 {
4555        self.0
4556    }
4557}
4558impl core::fmt::Debug for OpticalFlowSessionBindingPointNV {
4559    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4560        match self.0 {
4561            0i32 => f.write_str("UNKNOWN"),
4562            1i32 => f.write_str("INPUT"),
4563            2i32 => f.write_str("REFERENCE"),
4564            3i32 => f.write_str("HINT"),
4565            4i32 => f.write_str("FLOW_VECTOR"),
4566            5i32 => f.write_str("BACKWARD_FLOW_VECTOR"),
4567            6i32 => f.write_str("COST"),
4568            7i32 => f.write_str("BACKWARD_COST"),
4569            8i32 => f.write_str("GLOBAL_FLOW"),
4570            other => {
4571                write!(f, "{}({})", stringify!(OpticalFlowSessionBindingPointNV), other)
4572            }
4573        }
4574    }
4575}
4576impl core::fmt::Display for OpticalFlowSessionBindingPointNV {
4577    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4578        core::fmt::Debug::fmt(self, f)
4579    }
4580}
4581impl core::error::Error for OpticalFlowSessionBindingPointNV {}
4582///[`VkOutOfBandQueueTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkOutOfBandQueueTypeNV.html)
4583#[repr(transparent)]
4584#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4585#[doc(alias = "VkOutOfBandQueueTypeNV")]
4586pub struct OutOfBandQueueTypeNV(i32);
4587impl OutOfBandQueueTypeNV {
4588    pub const RENDER: Self = Self(0i32);
4589    pub const PRESENT: Self = Self(1i32);
4590    #[inline]
4591    pub const fn from_raw(value: i32) -> Self {
4592        Self(value)
4593    }
4594    #[inline]
4595    pub const fn as_raw(self) -> i32 {
4596        self.0
4597    }
4598}
4599impl core::fmt::Debug for OutOfBandQueueTypeNV {
4600    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4601        match self.0 {
4602            0i32 => f.write_str("RENDER"),
4603            1i32 => f.write_str("PRESENT"),
4604            other => write!(f, "{}({})", stringify!(OutOfBandQueueTypeNV), other),
4605        }
4606    }
4607}
4608impl core::fmt::Display for OutOfBandQueueTypeNV {
4609    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4610        core::fmt::Debug::fmt(self, f)
4611    }
4612}
4613impl core::error::Error for OutOfBandQueueTypeNV {}
4614///[`VkPartitionedAccelerationStructureOpTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureOpTypeNV.html)
4615#[repr(transparent)]
4616#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4617#[doc(alias = "VkPartitionedAccelerationStructureOpTypeNV")]
4618pub struct PartitionedAccelerationStructureOpTypeNV(i32);
4619impl PartitionedAccelerationStructureOpTypeNV {
4620    pub const WRITE_INSTANCE: Self = Self(0i32);
4621    pub const UPDATE_INSTANCE: Self = Self(1i32);
4622    pub const WRITE_PARTITION_TRANSLATION: Self = Self(2i32);
4623    #[inline]
4624    pub const fn from_raw(value: i32) -> Self {
4625        Self(value)
4626    }
4627    #[inline]
4628    pub const fn as_raw(self) -> i32 {
4629        self.0
4630    }
4631}
4632impl core::fmt::Debug for PartitionedAccelerationStructureOpTypeNV {
4633    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4634        match self.0 {
4635            0i32 => f.write_str("WRITE_INSTANCE"),
4636            1i32 => f.write_str("UPDATE_INSTANCE"),
4637            2i32 => f.write_str("WRITE_PARTITION_TRANSLATION"),
4638            other => {
4639                write!(
4640                    f, "{}({})", stringify!(PartitionedAccelerationStructureOpTypeNV),
4641                    other
4642                )
4643            }
4644        }
4645    }
4646}
4647impl core::fmt::Display for PartitionedAccelerationStructureOpTypeNV {
4648    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4649        core::fmt::Debug::fmt(self, f)
4650    }
4651}
4652impl core::error::Error for PartitionedAccelerationStructureOpTypeNV {}
4653///[`VkPerformanceConfigurationTypeINTEL`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationTypeINTEL.html)
4654#[repr(transparent)]
4655#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4656#[doc(alias = "VkPerformanceConfigurationTypeINTEL")]
4657pub struct PerformanceConfigurationTypeINTEL(i32);
4658impl PerformanceConfigurationTypeINTEL {
4659    pub const COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED: Self = Self(0i32);
4660    #[inline]
4661    pub const fn from_raw(value: i32) -> Self {
4662        Self(value)
4663    }
4664    #[inline]
4665    pub const fn as_raw(self) -> i32 {
4666        self.0
4667    }
4668}
4669impl core::fmt::Debug for PerformanceConfigurationTypeINTEL {
4670    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4671        match self.0 {
4672            0i32 => f.write_str("COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED"),
4673            other => {
4674                write!(f, "{}({})", stringify!(PerformanceConfigurationTypeINTEL), other)
4675            }
4676        }
4677    }
4678}
4679impl core::fmt::Display for PerformanceConfigurationTypeINTEL {
4680    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4681        core::fmt::Debug::fmt(self, f)
4682    }
4683}
4684impl core::error::Error for PerformanceConfigurationTypeINTEL {}
4685///[`VkPerformanceCounterScopeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterScopeKHR.html)
4686#[repr(transparent)]
4687#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4688#[doc(alias = "VkPerformanceCounterScopeKHR")]
4689pub struct PerformanceCounterScopeKHR(i32);
4690impl PerformanceCounterScopeKHR {
4691    pub const COMMAND_BUFFER: Self = Self(0i32);
4692    pub const RENDER_PASS: Self = Self(1i32);
4693    pub const COMMAND: Self = Self(2i32);
4694    pub const QUERY_SCOPE_COMMAND_BUFFER: Self = Self::COMMAND_BUFFER;
4695    pub const QUERY_SCOPE_RENDER_PASS: Self = Self::RENDER_PASS;
4696    pub const QUERY_SCOPE_COMMAND: Self = Self::COMMAND;
4697    #[inline]
4698    pub const fn from_raw(value: i32) -> Self {
4699        Self(value)
4700    }
4701    #[inline]
4702    pub const fn as_raw(self) -> i32 {
4703        self.0
4704    }
4705}
4706impl core::fmt::Debug for PerformanceCounterScopeKHR {
4707    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4708        match self.0 {
4709            0i32 => f.write_str("COMMAND_BUFFER"),
4710            1i32 => f.write_str("RENDER_PASS"),
4711            2i32 => f.write_str("COMMAND"),
4712            other => write!(f, "{}({})", stringify!(PerformanceCounterScopeKHR), other),
4713        }
4714    }
4715}
4716impl core::fmt::Display for PerformanceCounterScopeKHR {
4717    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4718        core::fmt::Debug::fmt(self, f)
4719    }
4720}
4721impl core::error::Error for PerformanceCounterScopeKHR {}
4722///[`VkPerformanceCounterStorageKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterStorageKHR.html)
4723#[repr(transparent)]
4724#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4725#[doc(alias = "VkPerformanceCounterStorageKHR")]
4726pub struct PerformanceCounterStorageKHR(i32);
4727impl PerformanceCounterStorageKHR {
4728    pub const INT32: Self = Self(0i32);
4729    pub const INT64: Self = Self(1i32);
4730    pub const UINT32: Self = Self(2i32);
4731    pub const UINT64: Self = Self(3i32);
4732    pub const FLOAT32: Self = Self(4i32);
4733    pub const FLOAT64: Self = Self(5i32);
4734    #[inline]
4735    pub const fn from_raw(value: i32) -> Self {
4736        Self(value)
4737    }
4738    #[inline]
4739    pub const fn as_raw(self) -> i32 {
4740        self.0
4741    }
4742}
4743impl core::fmt::Debug for PerformanceCounterStorageKHR {
4744    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4745        match self.0 {
4746            0i32 => f.write_str("INT32"),
4747            1i32 => f.write_str("INT64"),
4748            2i32 => f.write_str("UINT32"),
4749            3i32 => f.write_str("UINT64"),
4750            4i32 => f.write_str("FLOAT32"),
4751            5i32 => f.write_str("FLOAT64"),
4752            other => write!(f, "{}({})", stringify!(PerformanceCounterStorageKHR), other),
4753        }
4754    }
4755}
4756impl core::fmt::Display for PerformanceCounterStorageKHR {
4757    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4758        core::fmt::Debug::fmt(self, f)
4759    }
4760}
4761impl core::error::Error for PerformanceCounterStorageKHR {}
4762///[`VkPerformanceCounterUnitKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterUnitKHR.html)
4763#[repr(transparent)]
4764#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4765#[doc(alias = "VkPerformanceCounterUnitKHR")]
4766pub struct PerformanceCounterUnitKHR(i32);
4767impl PerformanceCounterUnitKHR {
4768    pub const GENERIC: Self = Self(0i32);
4769    pub const PERCENTAGE: Self = Self(1i32);
4770    pub const NANOSECONDS: Self = Self(2i32);
4771    pub const BYTES: Self = Self(3i32);
4772    pub const BYTES_PER_SECOND: Self = Self(4i32);
4773    pub const KELVIN: Self = Self(5i32);
4774    pub const WATTS: Self = Self(6i32);
4775    pub const VOLTS: Self = Self(7i32);
4776    pub const AMPS: Self = Self(8i32);
4777    pub const HERTZ: Self = Self(9i32);
4778    pub const CYCLES: Self = Self(10i32);
4779    #[inline]
4780    pub const fn from_raw(value: i32) -> Self {
4781        Self(value)
4782    }
4783    #[inline]
4784    pub const fn as_raw(self) -> i32 {
4785        self.0
4786    }
4787}
4788impl core::fmt::Debug for PerformanceCounterUnitKHR {
4789    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4790        match self.0 {
4791            0i32 => f.write_str("GENERIC"),
4792            1i32 => f.write_str("PERCENTAGE"),
4793            2i32 => f.write_str("NANOSECONDS"),
4794            3i32 => f.write_str("BYTES"),
4795            4i32 => f.write_str("BYTES_PER_SECOND"),
4796            5i32 => f.write_str("KELVIN"),
4797            6i32 => f.write_str("WATTS"),
4798            7i32 => f.write_str("VOLTS"),
4799            8i32 => f.write_str("AMPS"),
4800            9i32 => f.write_str("HERTZ"),
4801            10i32 => f.write_str("CYCLES"),
4802            other => write!(f, "{}({})", stringify!(PerformanceCounterUnitKHR), other),
4803        }
4804    }
4805}
4806impl core::fmt::Display for PerformanceCounterUnitKHR {
4807    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4808        core::fmt::Debug::fmt(self, f)
4809    }
4810}
4811impl core::error::Error for PerformanceCounterUnitKHR {}
4812///[`VkPerformanceOverrideTypeINTEL`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceOverrideTypeINTEL.html)
4813#[repr(transparent)]
4814#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4815#[doc(alias = "VkPerformanceOverrideTypeINTEL")]
4816pub struct PerformanceOverrideTypeINTEL(i32);
4817impl PerformanceOverrideTypeINTEL {
4818    pub const NULL_HARDWARE: Self = Self(0i32);
4819    pub const FLUSH_GPU_CACHES: Self = Self(1i32);
4820    #[inline]
4821    pub const fn from_raw(value: i32) -> Self {
4822        Self(value)
4823    }
4824    #[inline]
4825    pub const fn as_raw(self) -> i32 {
4826        self.0
4827    }
4828}
4829impl core::fmt::Debug for PerformanceOverrideTypeINTEL {
4830    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4831        match self.0 {
4832            0i32 => f.write_str("NULL_HARDWARE"),
4833            1i32 => f.write_str("FLUSH_GPU_CACHES"),
4834            other => write!(f, "{}({})", stringify!(PerformanceOverrideTypeINTEL), other),
4835        }
4836    }
4837}
4838impl core::fmt::Display for PerformanceOverrideTypeINTEL {
4839    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4840        core::fmt::Debug::fmt(self, f)
4841    }
4842}
4843impl core::error::Error for PerformanceOverrideTypeINTEL {}
4844///[`VkPerformanceParameterTypeINTEL`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceParameterTypeINTEL.html)
4845#[repr(transparent)]
4846#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4847#[doc(alias = "VkPerformanceParameterTypeINTEL")]
4848pub struct PerformanceParameterTypeINTEL(i32);
4849impl PerformanceParameterTypeINTEL {
4850    pub const HW_COUNTERS_SUPPORTED: Self = Self(0i32);
4851    pub const STREAM_MARKER_VALID_BITS: Self = Self(1i32);
4852    #[inline]
4853    pub const fn from_raw(value: i32) -> Self {
4854        Self(value)
4855    }
4856    #[inline]
4857    pub const fn as_raw(self) -> i32 {
4858        self.0
4859    }
4860}
4861impl core::fmt::Debug for PerformanceParameterTypeINTEL {
4862    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4863        match self.0 {
4864            0i32 => f.write_str("HW_COUNTERS_SUPPORTED"),
4865            1i32 => f.write_str("STREAM_MARKER_VALID_BITS"),
4866            other => {
4867                write!(f, "{}({})", stringify!(PerformanceParameterTypeINTEL), other)
4868            }
4869        }
4870    }
4871}
4872impl core::fmt::Display for PerformanceParameterTypeINTEL {
4873    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4874        core::fmt::Debug::fmt(self, f)
4875    }
4876}
4877impl core::error::Error for PerformanceParameterTypeINTEL {}
4878///[`VkPerformanceValueTypeINTEL`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceValueTypeINTEL.html)
4879#[repr(transparent)]
4880#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4881#[doc(alias = "VkPerformanceValueTypeINTEL")]
4882pub struct PerformanceValueTypeINTEL(i32);
4883impl PerformanceValueTypeINTEL {
4884    pub const UINT32: Self = Self(0i32);
4885    pub const UINT64: Self = Self(1i32);
4886    pub const FLOAT: Self = Self(2i32);
4887    pub const BOOL: Self = Self(3i32);
4888    pub const STRING: Self = Self(4i32);
4889    #[inline]
4890    pub const fn from_raw(value: i32) -> Self {
4891        Self(value)
4892    }
4893    #[inline]
4894    pub const fn as_raw(self) -> i32 {
4895        self.0
4896    }
4897}
4898impl core::fmt::Debug for PerformanceValueTypeINTEL {
4899    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4900        match self.0 {
4901            0i32 => f.write_str("UINT32"),
4902            1i32 => f.write_str("UINT64"),
4903            2i32 => f.write_str("FLOAT"),
4904            3i32 => f.write_str("BOOL"),
4905            4i32 => f.write_str("STRING"),
4906            other => write!(f, "{}({})", stringify!(PerformanceValueTypeINTEL), other),
4907        }
4908    }
4909}
4910impl core::fmt::Display for PerformanceValueTypeINTEL {
4911    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4912        core::fmt::Debug::fmt(self, f)
4913    }
4914}
4915impl core::error::Error for PerformanceValueTypeINTEL {}
4916///[`VkPhysicalDeviceDataGraphOperationTypeARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationTypeARM.html)
4917#[repr(transparent)]
4918#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4919#[doc(alias = "VkPhysicalDeviceDataGraphOperationTypeARM")]
4920pub struct PhysicalDeviceDataGraphOperationTypeARM(i32);
4921impl PhysicalDeviceDataGraphOperationTypeARM {
4922    pub const SPIRV_EXTENDED_INSTRUCTION_SET: Self = Self(0i32);
4923    pub const NEURAL_MODEL: Self = Self(1000629000i32);
4924    pub const BUILTIN_MODEL: Self = Self(1000629001i32);
4925    #[inline]
4926    pub const fn from_raw(value: i32) -> Self {
4927        Self(value)
4928    }
4929    #[inline]
4930    pub const fn as_raw(self) -> i32 {
4931        self.0
4932    }
4933}
4934impl core::fmt::Debug for PhysicalDeviceDataGraphOperationTypeARM {
4935    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4936        match self.0 {
4937            0i32 => f.write_str("SPIRV_EXTENDED_INSTRUCTION_SET"),
4938            1000629000i32 => f.write_str("NEURAL_MODEL"),
4939            1000629001i32 => f.write_str("BUILTIN_MODEL"),
4940            other => {
4941                write!(
4942                    f, "{}({})", stringify!(PhysicalDeviceDataGraphOperationTypeARM),
4943                    other
4944                )
4945            }
4946        }
4947    }
4948}
4949impl core::fmt::Display for PhysicalDeviceDataGraphOperationTypeARM {
4950    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4951        core::fmt::Debug::fmt(self, f)
4952    }
4953}
4954impl core::error::Error for PhysicalDeviceDataGraphOperationTypeARM {}
4955///[`VkPhysicalDeviceDataGraphProcessingEngineTypeARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineTypeARM.html)
4956#[repr(transparent)]
4957#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4958#[doc(alias = "VkPhysicalDeviceDataGraphProcessingEngineTypeARM")]
4959pub struct PhysicalDeviceDataGraphProcessingEngineTypeARM(i32);
4960impl PhysicalDeviceDataGraphProcessingEngineTypeARM {
4961    pub const DEFAULT: Self = Self(0i32);
4962    pub const NEURAL: Self = Self(1000629000i32);
4963    pub const COMPUTE: Self = Self(1000629001i32);
4964    #[inline]
4965    pub const fn from_raw(value: i32) -> Self {
4966        Self(value)
4967    }
4968    #[inline]
4969    pub const fn as_raw(self) -> i32 {
4970        self.0
4971    }
4972}
4973impl core::fmt::Debug for PhysicalDeviceDataGraphProcessingEngineTypeARM {
4974    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4975        match self.0 {
4976            0i32 => f.write_str("DEFAULT"),
4977            1000629000i32 => f.write_str("NEURAL"),
4978            1000629001i32 => f.write_str("COMPUTE"),
4979            other => {
4980                write!(
4981                    f, "{}({})",
4982                    stringify!(PhysicalDeviceDataGraphProcessingEngineTypeARM), other
4983                )
4984            }
4985        }
4986    }
4987}
4988impl core::fmt::Display for PhysicalDeviceDataGraphProcessingEngineTypeARM {
4989    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
4990        core::fmt::Debug::fmt(self, f)
4991    }
4992}
4993impl core::error::Error for PhysicalDeviceDataGraphProcessingEngineTypeARM {}
4994///[`VkPhysicalDeviceLayeredApiKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiKHR.html)
4995#[repr(transparent)]
4996#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
4997#[doc(alias = "VkPhysicalDeviceLayeredApiKHR")]
4998pub struct PhysicalDeviceLayeredApiKHR(i32);
4999impl PhysicalDeviceLayeredApiKHR {
5000    pub const VULKAN: Self = Self(0i32);
5001    pub const D3D12: Self = Self(1i32);
5002    pub const METAL: Self = Self(2i32);
5003    pub const OPENGL: Self = Self(3i32);
5004    pub const OPENGLES: Self = Self(4i32);
5005    #[inline]
5006    pub const fn from_raw(value: i32) -> Self {
5007        Self(value)
5008    }
5009    #[inline]
5010    pub const fn as_raw(self) -> i32 {
5011        self.0
5012    }
5013}
5014impl core::fmt::Debug for PhysicalDeviceLayeredApiKHR {
5015    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5016        match self.0 {
5017            0i32 => f.write_str("VULKAN"),
5018            1i32 => f.write_str("D3D12"),
5019            2i32 => f.write_str("METAL"),
5020            3i32 => f.write_str("OPENGL"),
5021            4i32 => f.write_str("OPENGLES"),
5022            other => write!(f, "{}({})", stringify!(PhysicalDeviceLayeredApiKHR), other),
5023        }
5024    }
5025}
5026impl core::fmt::Display for PhysicalDeviceLayeredApiKHR {
5027    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5028        core::fmt::Debug::fmt(self, f)
5029    }
5030}
5031impl core::error::Error for PhysicalDeviceLayeredApiKHR {}
5032///[`VkPhysicalDeviceType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceType.html)
5033#[repr(transparent)]
5034#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5035#[doc(alias = "VkPhysicalDeviceType")]
5036pub struct PhysicalDeviceType(i32);
5037impl PhysicalDeviceType {
5038    pub const OTHER: Self = Self(0i32);
5039    pub const INTEGRATED_GPU: Self = Self(1i32);
5040    pub const DISCRETE_GPU: Self = Self(2i32);
5041    pub const VIRTUAL_GPU: Self = Self(3i32);
5042    pub const CPU: Self = Self(4i32);
5043    #[inline]
5044    pub const fn from_raw(value: i32) -> Self {
5045        Self(value)
5046    }
5047    #[inline]
5048    pub const fn as_raw(self) -> i32 {
5049        self.0
5050    }
5051}
5052impl core::fmt::Debug for PhysicalDeviceType {
5053    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5054        match self.0 {
5055            0i32 => f.write_str("OTHER"),
5056            1i32 => f.write_str("INTEGRATED_GPU"),
5057            2i32 => f.write_str("DISCRETE_GPU"),
5058            3i32 => f.write_str("VIRTUAL_GPU"),
5059            4i32 => f.write_str("CPU"),
5060            other => write!(f, "{}({})", stringify!(PhysicalDeviceType), other),
5061        }
5062    }
5063}
5064impl core::fmt::Display for PhysicalDeviceType {
5065    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5066        core::fmt::Debug::fmt(self, f)
5067    }
5068}
5069impl core::error::Error for PhysicalDeviceType {}
5070///[`VkPipelineBindPoint`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBindPoint.html)
5071#[repr(transparent)]
5072#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5073#[doc(alias = "VkPipelineBindPoint")]
5074pub struct PipelineBindPoint(i32);
5075impl PipelineBindPoint {
5076    pub const GRAPHICS: Self = Self(0i32);
5077    pub const COMPUTE: Self = Self(1i32);
5078    pub const EXECUTION_GRAPH: Self = Self(1000134000i32);
5079    pub const RAY_TRACING: Self = Self(1000165000i32);
5080    pub const SUBPASS_SHADING: Self = Self(1000369003i32);
5081    pub const DATA_GRAPH: Self = Self(1000507000i32);
5082    #[inline]
5083    pub const fn from_raw(value: i32) -> Self {
5084        Self(value)
5085    }
5086    #[inline]
5087    pub const fn as_raw(self) -> i32 {
5088        self.0
5089    }
5090}
5091impl core::fmt::Debug for PipelineBindPoint {
5092    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5093        match self.0 {
5094            0i32 => f.write_str("GRAPHICS"),
5095            1i32 => f.write_str("COMPUTE"),
5096            1000134000i32 => f.write_str("EXECUTION_GRAPH"),
5097            1000165000i32 => f.write_str("RAY_TRACING"),
5098            1000369003i32 => f.write_str("SUBPASS_SHADING"),
5099            1000507000i32 => f.write_str("DATA_GRAPH"),
5100            other => write!(f, "{}({})", stringify!(PipelineBindPoint), other),
5101        }
5102    }
5103}
5104impl core::fmt::Display for PipelineBindPoint {
5105    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5106        core::fmt::Debug::fmt(self, f)
5107    }
5108}
5109impl core::error::Error for PipelineBindPoint {}
5110///[`VkPipelineCacheHeaderVersion`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html)
5111#[repr(transparent)]
5112#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5113#[doc(alias = "VkPipelineCacheHeaderVersion")]
5114pub struct PipelineCacheHeaderVersion(i32);
5115impl PipelineCacheHeaderVersion {
5116    pub const ONE: Self = Self(1i32);
5117    pub const SAFETY_CRITICAL_ONE: Self = Self(1000298001i32);
5118    pub const DATA_GRAPH: Self = Self(1000629000i32);
5119    #[inline]
5120    pub const fn from_raw(value: i32) -> Self {
5121        Self(value)
5122    }
5123    #[inline]
5124    pub const fn as_raw(self) -> i32 {
5125        self.0
5126    }
5127}
5128impl core::fmt::Debug for PipelineCacheHeaderVersion {
5129    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5130        match self.0 {
5131            1i32 => f.write_str("ONE"),
5132            1000298001i32 => f.write_str("SAFETY_CRITICAL_ONE"),
5133            1000629000i32 => f.write_str("DATA_GRAPH"),
5134            other => write!(f, "{}({})", stringify!(PipelineCacheHeaderVersion), other),
5135        }
5136    }
5137}
5138impl core::fmt::Display for PipelineCacheHeaderVersion {
5139    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5140        core::fmt::Debug::fmt(self, f)
5141    }
5142}
5143impl core::error::Error for PipelineCacheHeaderVersion {}
5144///[`VkPipelineCacheValidationVersion`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheValidationVersion.html)
5145#[repr(transparent)]
5146#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5147#[doc(alias = "VkPipelineCacheValidationVersion")]
5148pub struct PipelineCacheValidationVersion(i32);
5149impl PipelineCacheValidationVersion {
5150    pub const SAFETY_CRITICAL_ONE: Self = Self(1i32);
5151    #[inline]
5152    pub const fn from_raw(value: i32) -> Self {
5153        Self(value)
5154    }
5155    #[inline]
5156    pub const fn as_raw(self) -> i32 {
5157        self.0
5158    }
5159}
5160impl core::fmt::Debug for PipelineCacheValidationVersion {
5161    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5162        match self.0 {
5163            1i32 => f.write_str("SAFETY_CRITICAL_ONE"),
5164            other => {
5165                write!(f, "{}({})", stringify!(PipelineCacheValidationVersion), other)
5166            }
5167        }
5168    }
5169}
5170impl core::fmt::Display for PipelineCacheValidationVersion {
5171    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5172        core::fmt::Debug::fmt(self, f)
5173    }
5174}
5175impl core::error::Error for PipelineCacheValidationVersion {}
5176///[`VkPipelineExecutableStatisticFormatKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutableStatisticFormatKHR.html)
5177#[repr(transparent)]
5178#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5179#[doc(alias = "VkPipelineExecutableStatisticFormatKHR")]
5180pub struct PipelineExecutableStatisticFormatKHR(i32);
5181impl PipelineExecutableStatisticFormatKHR {
5182    pub const BOOL32: Self = Self(0i32);
5183    pub const INT64: Self = Self(1i32);
5184    pub const UINT64: Self = Self(2i32);
5185    pub const FLOAT64: Self = Self(3i32);
5186    #[inline]
5187    pub const fn from_raw(value: i32) -> Self {
5188        Self(value)
5189    }
5190    #[inline]
5191    pub const fn as_raw(self) -> i32 {
5192        self.0
5193    }
5194}
5195impl core::fmt::Debug for PipelineExecutableStatisticFormatKHR {
5196    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5197        match self.0 {
5198            0i32 => f.write_str("BOOL32"),
5199            1i32 => f.write_str("INT64"),
5200            2i32 => f.write_str("UINT64"),
5201            3i32 => f.write_str("FLOAT64"),
5202            other => {
5203                write!(
5204                    f, "{}({})", stringify!(PipelineExecutableStatisticFormatKHR), other
5205                )
5206            }
5207        }
5208    }
5209}
5210impl core::fmt::Display for PipelineExecutableStatisticFormatKHR {
5211    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5212        core::fmt::Debug::fmt(self, f)
5213    }
5214}
5215impl core::error::Error for PipelineExecutableStatisticFormatKHR {}
5216///[`VkPipelineMatchControl`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineMatchControl.html)
5217#[repr(transparent)]
5218#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5219#[doc(alias = "VkPipelineMatchControl")]
5220pub struct PipelineMatchControl(i32);
5221impl PipelineMatchControl {
5222    pub const APPLICATION_UUID_EXACT_MATCH: Self = Self(0i32);
5223    #[inline]
5224    pub const fn from_raw(value: i32) -> Self {
5225        Self(value)
5226    }
5227    #[inline]
5228    pub const fn as_raw(self) -> i32 {
5229        self.0
5230    }
5231}
5232impl core::fmt::Debug for PipelineMatchControl {
5233    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5234        match self.0 {
5235            0i32 => f.write_str("APPLICATION_UUID_EXACT_MATCH"),
5236            other => write!(f, "{}({})", stringify!(PipelineMatchControl), other),
5237        }
5238    }
5239}
5240impl core::fmt::Display for PipelineMatchControl {
5241    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5242        core::fmt::Debug::fmt(self, f)
5243    }
5244}
5245impl core::error::Error for PipelineMatchControl {}
5246///[`VkPipelineRobustnessBufferBehavior`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRobustnessBufferBehavior.html)
5247#[repr(transparent)]
5248#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5249#[doc(alias = "VkPipelineRobustnessBufferBehavior")]
5250pub struct PipelineRobustnessBufferBehavior(i32);
5251impl PipelineRobustnessBufferBehavior {
5252    pub const DEVICE_DEFAULT: Self = Self(0i32);
5253    pub const DISABLED: Self = Self(1i32);
5254    pub const ROBUST_BUFFER_ACCESS: Self = Self(2i32);
5255    pub const ROBUST_BUFFER_ACCESS_2: Self = Self(3i32);
5256    #[inline]
5257    pub const fn from_raw(value: i32) -> Self {
5258        Self(value)
5259    }
5260    #[inline]
5261    pub const fn as_raw(self) -> i32 {
5262        self.0
5263    }
5264}
5265impl core::fmt::Debug for PipelineRobustnessBufferBehavior {
5266    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5267        match self.0 {
5268            0i32 => f.write_str("DEVICE_DEFAULT"),
5269            1i32 => f.write_str("DISABLED"),
5270            2i32 => f.write_str("ROBUST_BUFFER_ACCESS"),
5271            3i32 => f.write_str("ROBUST_BUFFER_ACCESS_2"),
5272            other => {
5273                write!(f, "{}({})", stringify!(PipelineRobustnessBufferBehavior), other)
5274            }
5275        }
5276    }
5277}
5278impl core::fmt::Display for PipelineRobustnessBufferBehavior {
5279    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5280        core::fmt::Debug::fmt(self, f)
5281    }
5282}
5283impl core::error::Error for PipelineRobustnessBufferBehavior {}
5284///[`VkPipelineRobustnessImageBehavior`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRobustnessImageBehavior.html)
5285#[repr(transparent)]
5286#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5287#[doc(alias = "VkPipelineRobustnessImageBehavior")]
5288pub struct PipelineRobustnessImageBehavior(i32);
5289impl PipelineRobustnessImageBehavior {
5290    pub const DEVICE_DEFAULT: Self = Self(0i32);
5291    pub const DISABLED: Self = Self(1i32);
5292    pub const ROBUST_IMAGE_ACCESS: Self = Self(2i32);
5293    pub const ROBUST_IMAGE_ACCESS_2: Self = Self(3i32);
5294    #[inline]
5295    pub const fn from_raw(value: i32) -> Self {
5296        Self(value)
5297    }
5298    #[inline]
5299    pub const fn as_raw(self) -> i32 {
5300        self.0
5301    }
5302}
5303impl core::fmt::Debug for PipelineRobustnessImageBehavior {
5304    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5305        match self.0 {
5306            0i32 => f.write_str("DEVICE_DEFAULT"),
5307            1i32 => f.write_str("DISABLED"),
5308            2i32 => f.write_str("ROBUST_IMAGE_ACCESS"),
5309            3i32 => f.write_str("ROBUST_IMAGE_ACCESS_2"),
5310            other => {
5311                write!(f, "{}({})", stringify!(PipelineRobustnessImageBehavior), other)
5312            }
5313        }
5314    }
5315}
5316impl core::fmt::Display for PipelineRobustnessImageBehavior {
5317    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5318        core::fmt::Debug::fmt(self, f)
5319    }
5320}
5321impl core::error::Error for PipelineRobustnessImageBehavior {}
5322///[`VkPointClippingBehavior`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPointClippingBehavior.html)
5323#[repr(transparent)]
5324#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5325#[doc(alias = "VkPointClippingBehavior")]
5326pub struct PointClippingBehavior(i32);
5327impl PointClippingBehavior {
5328    pub const ALL_CLIP_PLANES: Self = Self(0i32);
5329    pub const USER_CLIP_PLANES_ONLY: Self = Self(1i32);
5330    #[inline]
5331    pub const fn from_raw(value: i32) -> Self {
5332        Self(value)
5333    }
5334    #[inline]
5335    pub const fn as_raw(self) -> i32 {
5336        self.0
5337    }
5338}
5339impl core::fmt::Debug for PointClippingBehavior {
5340    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5341        match self.0 {
5342            0i32 => f.write_str("ALL_CLIP_PLANES"),
5343            1i32 => f.write_str("USER_CLIP_PLANES_ONLY"),
5344            other => write!(f, "{}({})", stringify!(PointClippingBehavior), other),
5345        }
5346    }
5347}
5348impl core::fmt::Display for PointClippingBehavior {
5349    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5350        core::fmt::Debug::fmt(self, f)
5351    }
5352}
5353impl core::error::Error for PointClippingBehavior {}
5354///[`VkPolygonMode`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPolygonMode.html)
5355#[repr(transparent)]
5356#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5357#[doc(alias = "VkPolygonMode")]
5358pub struct PolygonMode(i32);
5359impl PolygonMode {
5360    pub const FILL: Self = Self(0i32);
5361    pub const LINE: Self = Self(1i32);
5362    pub const POINT: Self = Self(2i32);
5363    pub const FILL_RECTANGLE: Self = Self(1000153000i32);
5364    #[inline]
5365    pub const fn from_raw(value: i32) -> Self {
5366        Self(value)
5367    }
5368    #[inline]
5369    pub const fn as_raw(self) -> i32 {
5370        self.0
5371    }
5372}
5373impl core::fmt::Debug for PolygonMode {
5374    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5375        match self.0 {
5376            0i32 => f.write_str("FILL"),
5377            1i32 => f.write_str("LINE"),
5378            2i32 => f.write_str("POINT"),
5379            1000153000i32 => f.write_str("FILL_RECTANGLE"),
5380            other => write!(f, "{}({})", stringify!(PolygonMode), other),
5381        }
5382    }
5383}
5384impl core::fmt::Display for PolygonMode {
5385    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5386        core::fmt::Debug::fmt(self, f)
5387    }
5388}
5389impl core::error::Error for PolygonMode {}
5390///[`VkPresentModeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentModeKHR.html)
5391#[repr(transparent)]
5392#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5393#[doc(alias = "VkPresentModeKHR")]
5394pub struct PresentModeKHR(i32);
5395impl PresentModeKHR {
5396    pub const IMMEDIATE: Self = Self(0i32);
5397    pub const MAILBOX: Self = Self(1i32);
5398    pub const FIFO: Self = Self(2i32);
5399    pub const FIFO_RELAXED: Self = Self(3i32);
5400    pub const SHARED_DEMAND_REFRESH: Self = Self(1000111000i32);
5401    pub const SHARED_CONTINUOUS_REFRESH: Self = Self(1000111001i32);
5402    #[inline]
5403    pub const fn from_raw(value: i32) -> Self {
5404        Self(value)
5405    }
5406    #[inline]
5407    pub const fn as_raw(self) -> i32 {
5408        self.0
5409    }
5410}
5411impl core::fmt::Debug for PresentModeKHR {
5412    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5413        match self.0 {
5414            0i32 => f.write_str("IMMEDIATE"),
5415            1i32 => f.write_str("MAILBOX"),
5416            2i32 => f.write_str("FIFO"),
5417            3i32 => f.write_str("FIFO_RELAXED"),
5418            1000111000i32 => f.write_str("SHARED_DEMAND_REFRESH"),
5419            1000111001i32 => f.write_str("SHARED_CONTINUOUS_REFRESH"),
5420            other => write!(f, "{}({})", stringify!(PresentModeKHR), other),
5421        }
5422    }
5423}
5424impl core::fmt::Display for PresentModeKHR {
5425    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5426        core::fmt::Debug::fmt(self, f)
5427    }
5428}
5429impl core::error::Error for PresentModeKHR {}
5430///[`VkPrimitiveTopology`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrimitiveTopology.html)
5431#[repr(transparent)]
5432#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5433#[doc(alias = "VkPrimitiveTopology")]
5434pub struct PrimitiveTopology(i32);
5435impl PrimitiveTopology {
5436    pub const POINT_LIST: Self = Self(0i32);
5437    pub const LINE_LIST: Self = Self(1i32);
5438    pub const LINE_STRIP: Self = Self(2i32);
5439    pub const TRIANGLE_LIST: Self = Self(3i32);
5440    pub const TRIANGLE_STRIP: Self = Self(4i32);
5441    pub const TRIANGLE_FAN: Self = Self(5i32);
5442    pub const LINE_LIST_WITH_ADJACENCY: Self = Self(6i32);
5443    pub const LINE_STRIP_WITH_ADJACENCY: Self = Self(7i32);
5444    pub const TRIANGLE_LIST_WITH_ADJACENCY: Self = Self(8i32);
5445    pub const TRIANGLE_STRIP_WITH_ADJACENCY: Self = Self(9i32);
5446    pub const PATCH_LIST: Self = Self(10i32);
5447    #[inline]
5448    pub const fn from_raw(value: i32) -> Self {
5449        Self(value)
5450    }
5451    #[inline]
5452    pub const fn as_raw(self) -> i32 {
5453        self.0
5454    }
5455}
5456impl core::fmt::Debug for PrimitiveTopology {
5457    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5458        match self.0 {
5459            0i32 => f.write_str("POINT_LIST"),
5460            1i32 => f.write_str("LINE_LIST"),
5461            2i32 => f.write_str("LINE_STRIP"),
5462            3i32 => f.write_str("TRIANGLE_LIST"),
5463            4i32 => f.write_str("TRIANGLE_STRIP"),
5464            5i32 => f.write_str("TRIANGLE_FAN"),
5465            6i32 => f.write_str("LINE_LIST_WITH_ADJACENCY"),
5466            7i32 => f.write_str("LINE_STRIP_WITH_ADJACENCY"),
5467            8i32 => f.write_str("TRIANGLE_LIST_WITH_ADJACENCY"),
5468            9i32 => f.write_str("TRIANGLE_STRIP_WITH_ADJACENCY"),
5469            10i32 => f.write_str("PATCH_LIST"),
5470            other => write!(f, "{}({})", stringify!(PrimitiveTopology), other),
5471        }
5472    }
5473}
5474impl core::fmt::Display for PrimitiveTopology {
5475    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5476        core::fmt::Debug::fmt(self, f)
5477    }
5478}
5479impl core::error::Error for PrimitiveTopology {}
5480///[`VkProvokingVertexModeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkProvokingVertexModeEXT.html)
5481#[repr(transparent)]
5482#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5483#[doc(alias = "VkProvokingVertexModeEXT")]
5484pub struct ProvokingVertexModeEXT(i32);
5485impl ProvokingVertexModeEXT {
5486    pub const FIRST_VERTEX: Self = Self(0i32);
5487    pub const LAST_VERTEX: Self = Self(1i32);
5488    #[inline]
5489    pub const fn from_raw(value: i32) -> Self {
5490        Self(value)
5491    }
5492    #[inline]
5493    pub const fn as_raw(self) -> i32 {
5494        self.0
5495    }
5496}
5497impl core::fmt::Debug for ProvokingVertexModeEXT {
5498    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5499        match self.0 {
5500            0i32 => f.write_str("FIRST_VERTEX"),
5501            1i32 => f.write_str("LAST_VERTEX"),
5502            other => write!(f, "{}({})", stringify!(ProvokingVertexModeEXT), other),
5503        }
5504    }
5505}
5506impl core::fmt::Display for ProvokingVertexModeEXT {
5507    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5508        core::fmt::Debug::fmt(self, f)
5509    }
5510}
5511impl core::error::Error for ProvokingVertexModeEXT {}
5512///[`VkQueryPoolSamplingModeINTEL`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolSamplingModeINTEL.html)
5513#[repr(transparent)]
5514#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5515#[doc(alias = "VkQueryPoolSamplingModeINTEL")]
5516pub struct QueryPoolSamplingModeINTEL(i32);
5517impl QueryPoolSamplingModeINTEL {
5518    pub const MANUAL: Self = Self(0i32);
5519    #[inline]
5520    pub const fn from_raw(value: i32) -> Self {
5521        Self(value)
5522    }
5523    #[inline]
5524    pub const fn as_raw(self) -> i32 {
5525        self.0
5526    }
5527}
5528impl core::fmt::Debug for QueryPoolSamplingModeINTEL {
5529    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5530        match self.0 {
5531            0i32 => f.write_str("MANUAL"),
5532            other => write!(f, "{}({})", stringify!(QueryPoolSamplingModeINTEL), other),
5533        }
5534    }
5535}
5536impl core::fmt::Display for QueryPoolSamplingModeINTEL {
5537    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5538        core::fmt::Debug::fmt(self, f)
5539    }
5540}
5541impl core::error::Error for QueryPoolSamplingModeINTEL {}
5542///[`VkQueryResultStatusKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryResultStatusKHR.html)
5543#[repr(transparent)]
5544#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5545#[doc(alias = "VkQueryResultStatusKHR")]
5546pub struct QueryResultStatusKHR(i32);
5547impl QueryResultStatusKHR {
5548    pub const ERROR: Self = Self(-1i32);
5549    pub const NOT_READY: Self = Self(0i32);
5550    pub const COMPLETE: Self = Self(1i32);
5551    pub const INSUFFICIENT_BITSTREAM_BUFFER_RANGE: Self = Self(-1000299000i32);
5552    #[inline]
5553    pub const fn from_raw(value: i32) -> Self {
5554        Self(value)
5555    }
5556    #[inline]
5557    pub const fn as_raw(self) -> i32 {
5558        self.0
5559    }
5560}
5561impl core::fmt::Debug for QueryResultStatusKHR {
5562    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5563        match self.0 {
5564            -1i32 => f.write_str("ERROR"),
5565            0i32 => f.write_str("NOT_READY"),
5566            1i32 => f.write_str("COMPLETE"),
5567            -1000299000i32 => f.write_str("INSUFFICIENT_BITSTREAM_BUFFER_RANGE"),
5568            other => write!(f, "{}({})", stringify!(QueryResultStatusKHR), other),
5569        }
5570    }
5571}
5572impl core::fmt::Display for QueryResultStatusKHR {
5573    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5574        core::fmt::Debug::fmt(self, f)
5575    }
5576}
5577impl core::error::Error for QueryResultStatusKHR {}
5578///[`VkQueryType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryType.html)
5579#[repr(transparent)]
5580#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5581#[doc(alias = "VkQueryType")]
5582pub struct QueryType(i32);
5583impl QueryType {
5584    pub const OCCLUSION: Self = Self(0i32);
5585    ///Optional
5586    pub const PIPELINE_STATISTICS: Self = Self(1i32);
5587    pub const TIMESTAMP: Self = Self(2i32);
5588    pub const RESULT_STATUS_ONLY: Self = Self(1000023000i32);
5589    pub const TRANSFORM_FEEDBACK_STREAM: Self = Self(1000028004i32);
5590    pub const PERFORMANCE_QUERY: Self = Self(1000116000i32);
5591    pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE: Self = Self(1000150000i32);
5592    pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE: Self = Self(1000150001i32);
5593    pub const VIDEO_ENCODE_FEEDBACK: Self = Self(1000299000i32);
5594    pub const MESH_PRIMITIVES_GENERATED: Self = Self(1000328000i32);
5595    pub const PRIMITIVES_GENERATED: Self = Self(1000382000i32);
5596    pub const ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS: Self = Self(
5597        1000386000i32,
5598    );
5599    pub const ACCELERATION_STRUCTURE_SIZE: Self = Self(1000386001i32);
5600    pub const MICROMAP_SERIALIZATION_SIZE: Self = Self(1000396000i32);
5601    pub const MICROMAP_COMPACTED_SIZE: Self = Self(1000396001i32);
5602    #[inline]
5603    pub const fn from_raw(value: i32) -> Self {
5604        Self(value)
5605    }
5606    #[inline]
5607    pub const fn as_raw(self) -> i32 {
5608        self.0
5609    }
5610}
5611impl core::fmt::Debug for QueryType {
5612    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5613        match self.0 {
5614            0i32 => f.write_str("OCCLUSION"),
5615            1i32 => f.write_str("PIPELINE_STATISTICS"),
5616            2i32 => f.write_str("TIMESTAMP"),
5617            1000023000i32 => f.write_str("RESULT_STATUS_ONLY"),
5618            1000028004i32 => f.write_str("TRANSFORM_FEEDBACK_STREAM"),
5619            1000116000i32 => f.write_str("PERFORMANCE_QUERY"),
5620            1000150000i32 => f.write_str("ACCELERATION_STRUCTURE_COMPACTED_SIZE"),
5621            1000150001i32 => f.write_str("ACCELERATION_STRUCTURE_SERIALIZATION_SIZE"),
5622            1000299000i32 => f.write_str("VIDEO_ENCODE_FEEDBACK"),
5623            1000328000i32 => f.write_str("MESH_PRIMITIVES_GENERATED"),
5624            1000382000i32 => f.write_str("PRIMITIVES_GENERATED"),
5625            1000386000i32 => {
5626                f.write_str("ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS")
5627            }
5628            1000386001i32 => f.write_str("ACCELERATION_STRUCTURE_SIZE"),
5629            1000396000i32 => f.write_str("MICROMAP_SERIALIZATION_SIZE"),
5630            1000396001i32 => f.write_str("MICROMAP_COMPACTED_SIZE"),
5631            other => write!(f, "{}({})", stringify!(QueryType), other),
5632        }
5633    }
5634}
5635impl core::fmt::Display for QueryType {
5636    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5637        core::fmt::Debug::fmt(self, f)
5638    }
5639}
5640impl core::error::Error for QueryType {}
5641///[`VkQueueGlobalPriority`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueGlobalPriority.html)
5642#[repr(transparent)]
5643#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5644#[doc(alias = "VkQueueGlobalPriority")]
5645pub struct QueueGlobalPriority(i32);
5646impl QueueGlobalPriority {
5647    pub const LOW: Self = Self(128i32);
5648    pub const MEDIUM: Self = Self(256i32);
5649    pub const HIGH: Self = Self(512i32);
5650    pub const REALTIME: Self = Self(1024i32);
5651    #[inline]
5652    pub const fn from_raw(value: i32) -> Self {
5653        Self(value)
5654    }
5655    #[inline]
5656    pub const fn as_raw(self) -> i32 {
5657        self.0
5658    }
5659}
5660impl core::fmt::Debug for QueueGlobalPriority {
5661    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5662        match self.0 {
5663            128i32 => f.write_str("LOW"),
5664            256i32 => f.write_str("MEDIUM"),
5665            512i32 => f.write_str("HIGH"),
5666            1024i32 => f.write_str("REALTIME"),
5667            other => write!(f, "{}({})", stringify!(QueueGlobalPriority), other),
5668        }
5669    }
5670}
5671impl core::fmt::Display for QueueGlobalPriority {
5672    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5673        core::fmt::Debug::fmt(self, f)
5674    }
5675}
5676impl core::error::Error for QueueGlobalPriority {}
5677///[`VkRasterizationOrderAMD`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRasterizationOrderAMD.html)
5678#[repr(transparent)]
5679#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5680#[doc(alias = "VkRasterizationOrderAMD")]
5681pub struct RasterizationOrderAMD(i32);
5682impl RasterizationOrderAMD {
5683    pub const STRICT: Self = Self(0i32);
5684    pub const RELAXED: Self = Self(1i32);
5685    #[inline]
5686    pub const fn from_raw(value: i32) -> Self {
5687        Self(value)
5688    }
5689    #[inline]
5690    pub const fn as_raw(self) -> i32 {
5691        self.0
5692    }
5693}
5694impl core::fmt::Debug for RasterizationOrderAMD {
5695    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5696        match self.0 {
5697            0i32 => f.write_str("STRICT"),
5698            1i32 => f.write_str("RELAXED"),
5699            other => write!(f, "{}({})", stringify!(RasterizationOrderAMD), other),
5700        }
5701    }
5702}
5703impl core::fmt::Display for RasterizationOrderAMD {
5704    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5705        core::fmt::Debug::fmt(self, f)
5706    }
5707}
5708impl core::error::Error for RasterizationOrderAMD {}
5709///[`VkRayTracingInvocationReorderModeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingInvocationReorderModeEXT.html)
5710#[repr(transparent)]
5711#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5712#[doc(alias = "VkRayTracingInvocationReorderModeEXT")]
5713pub struct RayTracingInvocationReorderModeEXT(i32);
5714impl RayTracingInvocationReorderModeEXT {
5715    pub const NONE: Self = Self(0i32);
5716    pub const REORDER: Self = Self(1i32);
5717    #[inline]
5718    pub const fn from_raw(value: i32) -> Self {
5719        Self(value)
5720    }
5721    #[inline]
5722    pub const fn as_raw(self) -> i32 {
5723        self.0
5724    }
5725}
5726impl core::fmt::Debug for RayTracingInvocationReorderModeEXT {
5727    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5728        match self.0 {
5729            0i32 => f.write_str("NONE"),
5730            1i32 => f.write_str("REORDER"),
5731            other => {
5732                write!(
5733                    f, "{}({})", stringify!(RayTracingInvocationReorderModeEXT), other
5734                )
5735            }
5736        }
5737    }
5738}
5739impl core::fmt::Display for RayTracingInvocationReorderModeEXT {
5740    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5741        core::fmt::Debug::fmt(self, f)
5742    }
5743}
5744impl core::error::Error for RayTracingInvocationReorderModeEXT {}
5745///[`VkRayTracingLssIndexingModeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingLssIndexingModeNV.html)
5746#[repr(transparent)]
5747#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5748#[doc(alias = "VkRayTracingLssIndexingModeNV")]
5749pub struct RayTracingLssIndexingModeNV(i32);
5750impl RayTracingLssIndexingModeNV {
5751    pub const LIST: Self = Self(0i32);
5752    pub const SUCCESSIVE: Self = Self(1i32);
5753    #[inline]
5754    pub const fn from_raw(value: i32) -> Self {
5755        Self(value)
5756    }
5757    #[inline]
5758    pub const fn as_raw(self) -> i32 {
5759        self.0
5760    }
5761}
5762impl core::fmt::Debug for RayTracingLssIndexingModeNV {
5763    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5764        match self.0 {
5765            0i32 => f.write_str("LIST"),
5766            1i32 => f.write_str("SUCCESSIVE"),
5767            other => write!(f, "{}({})", stringify!(RayTracingLssIndexingModeNV), other),
5768        }
5769    }
5770}
5771impl core::fmt::Display for RayTracingLssIndexingModeNV {
5772    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5773        core::fmt::Debug::fmt(self, f)
5774    }
5775}
5776impl core::error::Error for RayTracingLssIndexingModeNV {}
5777///[`VkRayTracingLssPrimitiveEndCapsModeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingLssPrimitiveEndCapsModeNV.html)
5778#[repr(transparent)]
5779#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5780#[doc(alias = "VkRayTracingLssPrimitiveEndCapsModeNV")]
5781pub struct RayTracingLssPrimitiveEndCapsModeNV(i32);
5782impl RayTracingLssPrimitiveEndCapsModeNV {
5783    pub const NONE: Self = Self(0i32);
5784    pub const CHAINED: Self = Self(1i32);
5785    #[inline]
5786    pub const fn from_raw(value: i32) -> Self {
5787        Self(value)
5788    }
5789    #[inline]
5790    pub const fn as_raw(self) -> i32 {
5791        self.0
5792    }
5793}
5794impl core::fmt::Debug for RayTracingLssPrimitiveEndCapsModeNV {
5795    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5796        match self.0 {
5797            0i32 => f.write_str("NONE"),
5798            1i32 => f.write_str("CHAINED"),
5799            other => {
5800                write!(
5801                    f, "{}({})", stringify!(RayTracingLssPrimitiveEndCapsModeNV), other
5802                )
5803            }
5804        }
5805    }
5806}
5807impl core::fmt::Display for RayTracingLssPrimitiveEndCapsModeNV {
5808    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5809        core::fmt::Debug::fmt(self, f)
5810    }
5811}
5812impl core::error::Error for RayTracingLssPrimitiveEndCapsModeNV {}
5813///[`VkRayTracingShaderGroupTypeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingShaderGroupTypeKHR.html)
5814#[repr(transparent)]
5815#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5816#[doc(alias = "VkRayTracingShaderGroupTypeKHR")]
5817pub struct RayTracingShaderGroupTypeKHR(i32);
5818impl RayTracingShaderGroupTypeKHR {
5819    pub const GENERAL: Self = Self(0i32);
5820    pub const TRIANGLES_HIT_GROUP: Self = Self(1i32);
5821    pub const PROCEDURAL_HIT_GROUP: Self = Self(2i32);
5822    #[inline]
5823    pub const fn from_raw(value: i32) -> Self {
5824        Self(value)
5825    }
5826    #[inline]
5827    pub const fn as_raw(self) -> i32 {
5828        self.0
5829    }
5830}
5831impl core::fmt::Debug for RayTracingShaderGroupTypeKHR {
5832    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5833        match self.0 {
5834            0i32 => f.write_str("GENERAL"),
5835            1i32 => f.write_str("TRIANGLES_HIT_GROUP"),
5836            2i32 => f.write_str("PROCEDURAL_HIT_GROUP"),
5837            other => write!(f, "{}({})", stringify!(RayTracingShaderGroupTypeKHR), other),
5838        }
5839    }
5840}
5841impl core::fmt::Display for RayTracingShaderGroupTypeKHR {
5842    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5843        core::fmt::Debug::fmt(self, f)
5844    }
5845}
5846impl core::error::Error for RayTracingShaderGroupTypeKHR {}
5847///[`VkResult`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkResult.html)
5848#[repr(transparent)]
5849#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
5850#[doc(alias = "VkResult")]
5851pub struct Result(i32);
5852impl Result {
5853    ///Command completed successfully
5854    pub const SUCCESS: Self = Self(0i32);
5855    ///A fence or query has not yet completed
5856    pub const NOT_READY: Self = Self(1i32);
5857    ///A wait operation has not completed in the specified time
5858    pub const TIMEOUT: Self = Self(2i32);
5859    ///An event is signaled
5860    pub const EVENT_SET: Self = Self(3i32);
5861    ///An event is unsignaled
5862    pub const EVENT_RESET: Self = Self(4i32);
5863    ///A return array was too small for the result
5864    pub const INCOMPLETE: Self = Self(5i32);
5865    ///A host memory allocation has failed
5866    pub const ERROR_OUT_OF_HOST_MEMORY: Self = Self(-1i32);
5867    ///A device memory allocation has failed
5868    pub const ERROR_OUT_OF_DEVICE_MEMORY: Self = Self(-2i32);
5869    ///Initialization of an object has failed
5870    pub const ERROR_INITIALIZATION_FAILED: Self = Self(-3i32);
5871    ///The logical device has been lost. See `devsandqueues-lost-device`
5872    pub const ERROR_DEVICE_LOST: Self = Self(-4i32);
5873    ///Mapping of a memory object has failed
5874    pub const ERROR_MEMORY_MAP_FAILED: Self = Self(-5i32);
5875    ///Layer specified does not exist
5876    pub const ERROR_LAYER_NOT_PRESENT: Self = Self(-6i32);
5877    ///Extension specified does not exist
5878    pub const ERROR_EXTENSION_NOT_PRESENT: Self = Self(-7i32);
5879    ///Requested feature is not available on this device
5880    pub const ERROR_FEATURE_NOT_PRESENT: Self = Self(-8i32);
5881    ///Unable to find a Vulkan driver
5882    pub const ERROR_INCOMPATIBLE_DRIVER: Self = Self(-9i32);
5883    ///Too many objects of the type have already been created
5884    pub const ERROR_TOO_MANY_OBJECTS: Self = Self(-10i32);
5885    ///Requested format is not supported on this device
5886    pub const ERROR_FORMAT_NOT_SUPPORTED: Self = Self(-11i32);
5887    ///A requested pool allocation has failed due to fragmentation of the pool's memory
5888    pub const ERROR_FRAGMENTED_POOL: Self = Self(-12i32);
5889    ///An unknown error has occurred, due to an implementation or application bug
5890    pub const ERROR_UNKNOWN: Self = Self(-13i32);
5891    pub const ERROR_VALIDATION_FAILED: Self = Self(-1000011001i32);
5892    pub const ERROR_OUT_OF_POOL_MEMORY: Self = Self(-1000069000i32);
5893    pub const ERROR_INVALID_EXTERNAL_HANDLE: Self = Self(-1000072003i32);
5894    pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: Self = Self(-1000257000i32);
5895    pub const ERROR_FRAGMENTATION: Self = Self(-1000161000i32);
5896    pub const PIPELINE_COMPILE_REQUIRED: Self = Self(1000297000i32);
5897    pub const ERROR_NOT_PERMITTED: Self = Self(-1000174001i32);
5898    pub const ERROR_INVALID_PIPELINE_CACHE_DATA: Self = Self(-1000298000i32);
5899    pub const ERROR_NO_PIPELINE_MATCH: Self = Self(-1000298001i32);
5900    pub const ERROR_SURFACE_LOST: Self = Self(-1000000000i32);
5901    pub const ERROR_NATIVE_WINDOW_IN_USE: Self = Self(-1000000001i32);
5902    pub const SUBOPTIMAL: Self = Self(1000001003i32);
5903    pub const ERROR_OUT_OF_DATE: Self = Self(-1000001004i32);
5904    pub const ERROR_INCOMPATIBLE_DISPLAY: Self = Self(-1000003001i32);
5905    pub const ERROR_INVALID_SHADER: Self = Self(-1000012000i32);
5906    pub const ERROR_IMAGE_USAGE_NOT_SUPPORTED: Self = Self(-1000023000i32);
5907    pub const ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED: Self = Self(-1000023001i32);
5908    pub const ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED: Self = Self(-1000023002i32);
5909    pub const ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED: Self = Self(-1000023003i32);
5910    pub const ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED: Self = Self(-1000023004i32);
5911    pub const ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED: Self = Self(-1000023005i32);
5912    pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT: Self = Self(
5913        -1000158000i32,
5914    );
5915    pub const ERROR_PRESENT_TIMING_QUEUE_FULL: Self = Self(-1000208000i32);
5916    pub const ERROR_INVALID_DEVICE_ADDRESS: Self = Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
5917    pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST: Self = Self(-1000255000i32);
5918    pub const THREAD_IDLE: Self = Self(1000268000i32);
5919    pub const THREAD_DONE: Self = Self(1000268001i32);
5920    pub const OPERATION_DEFERRED: Self = Self(1000268002i32);
5921    pub const OPERATION_NOT_DEFERRED: Self = Self(1000268003i32);
5922    pub const ERROR_PIPELINE_COMPILE_REQUIRED: Self = Self::PIPELINE_COMPILE_REQUIRED;
5923    pub const ERROR_INVALID_VIDEO_STD_PARAMETERS: Self = Self(-1000299000i32);
5924    pub const ERROR_COMPRESSION_EXHAUSTED: Self = Self(-1000338000i32);
5925    pub const INCOMPATIBLE_SHADER_BINARY: Self = Self(1000482000i32);
5926    pub const ERROR_INCOMPATIBLE_SHADER_BINARY: Self = Self::INCOMPATIBLE_SHADER_BINARY;
5927    pub const PIPELINE_BINARY_MISSING: Self = Self(1000483000i32);
5928    pub const ERROR_NOT_ENOUGH_SPACE: Self = Self(-1000483000i32);
5929    #[inline]
5930    pub const fn from_raw(value: i32) -> Self {
5931        Self(value)
5932    }
5933    #[inline]
5934    pub const fn as_raw(self) -> i32 {
5935        self.0
5936    }
5937}
5938impl core::fmt::Debug for Result {
5939    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
5940        match self.0 {
5941            0i32 => f.write_str("SUCCESS"),
5942            1i32 => f.write_str("NOT_READY"),
5943            2i32 => f.write_str("TIMEOUT"),
5944            3i32 => f.write_str("EVENT_SET"),
5945            4i32 => f.write_str("EVENT_RESET"),
5946            5i32 => f.write_str("INCOMPLETE"),
5947            -1i32 => f.write_str("ERROR_OUT_OF_HOST_MEMORY"),
5948            -2i32 => f.write_str("ERROR_OUT_OF_DEVICE_MEMORY"),
5949            -3i32 => f.write_str("ERROR_INITIALIZATION_FAILED"),
5950            -4i32 => f.write_str("ERROR_DEVICE_LOST"),
5951            -5i32 => f.write_str("ERROR_MEMORY_MAP_FAILED"),
5952            -6i32 => f.write_str("ERROR_LAYER_NOT_PRESENT"),
5953            -7i32 => f.write_str("ERROR_EXTENSION_NOT_PRESENT"),
5954            -8i32 => f.write_str("ERROR_FEATURE_NOT_PRESENT"),
5955            -9i32 => f.write_str("ERROR_INCOMPATIBLE_DRIVER"),
5956            -10i32 => f.write_str("ERROR_TOO_MANY_OBJECTS"),
5957            -11i32 => f.write_str("ERROR_FORMAT_NOT_SUPPORTED"),
5958            -12i32 => f.write_str("ERROR_FRAGMENTED_POOL"),
5959            -13i32 => f.write_str("ERROR_UNKNOWN"),
5960            -1000011001i32 => f.write_str("ERROR_VALIDATION_FAILED"),
5961            -1000069000i32 => f.write_str("ERROR_OUT_OF_POOL_MEMORY"),
5962            -1000072003i32 => f.write_str("ERROR_INVALID_EXTERNAL_HANDLE"),
5963            -1000257000i32 => f.write_str("ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"),
5964            -1000161000i32 => f.write_str("ERROR_FRAGMENTATION"),
5965            1000297000i32 => f.write_str("PIPELINE_COMPILE_REQUIRED"),
5966            -1000174001i32 => f.write_str("ERROR_NOT_PERMITTED"),
5967            -1000298000i32 => f.write_str("ERROR_INVALID_PIPELINE_CACHE_DATA"),
5968            -1000298001i32 => f.write_str("ERROR_NO_PIPELINE_MATCH"),
5969            -1000000000i32 => f.write_str("ERROR_SURFACE_LOST"),
5970            -1000000001i32 => f.write_str("ERROR_NATIVE_WINDOW_IN_USE"),
5971            1000001003i32 => f.write_str("SUBOPTIMAL"),
5972            -1000001004i32 => f.write_str("ERROR_OUT_OF_DATE"),
5973            -1000003001i32 => f.write_str("ERROR_INCOMPATIBLE_DISPLAY"),
5974            -1000012000i32 => f.write_str("ERROR_INVALID_SHADER"),
5975            -1000023000i32 => f.write_str("ERROR_IMAGE_USAGE_NOT_SUPPORTED"),
5976            -1000023001i32 => f.write_str("ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED"),
5977            -1000023002i32 => f.write_str("ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED"),
5978            -1000023003i32 => f.write_str("ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED"),
5979            -1000023004i32 => f.write_str("ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED"),
5980            -1000023005i32 => f.write_str("ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED"),
5981            -1000158000i32 => {
5982                f.write_str("ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT")
5983            }
5984            -1000208000i32 => f.write_str("ERROR_PRESENT_TIMING_QUEUE_FULL"),
5985            -1000255000i32 => f.write_str("ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST"),
5986            1000268000i32 => f.write_str("THREAD_IDLE"),
5987            1000268001i32 => f.write_str("THREAD_DONE"),
5988            1000268002i32 => f.write_str("OPERATION_DEFERRED"),
5989            1000268003i32 => f.write_str("OPERATION_NOT_DEFERRED"),
5990            -1000299000i32 => f.write_str("ERROR_INVALID_VIDEO_STD_PARAMETERS"),
5991            -1000338000i32 => f.write_str("ERROR_COMPRESSION_EXHAUSTED"),
5992            1000482000i32 => f.write_str("INCOMPATIBLE_SHADER_BINARY"),
5993            1000483000i32 => f.write_str("PIPELINE_BINARY_MISSING"),
5994            -1000483000i32 => f.write_str("ERROR_NOT_ENOUGH_SPACE"),
5995            other => write!(f, "{}({})", stringify!(Result), other),
5996        }
5997    }
5998}
5999impl core::fmt::Display for Result {
6000    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6001        core::fmt::Debug::fmt(self, f)
6002    }
6003}
6004impl core::error::Error for Result {}
6005///[`VkSamplerAddressMode`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerAddressMode.html)
6006#[repr(transparent)]
6007#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6008#[doc(alias = "VkSamplerAddressMode")]
6009pub struct SamplerAddressMode(i32);
6010impl SamplerAddressMode {
6011    pub const REPEAT: Self = Self(0i32);
6012    pub const MIRRORED_REPEAT: Self = Self(1i32);
6013    pub const CLAMP_TO_EDGE: Self = Self(2i32);
6014    pub const CLAMP_TO_BORDER: Self = Self(3i32);
6015    ///No need to add an extnumber attribute, since this uses a core enum value
6016    pub const MIRROR_CLAMP_TO_EDGE: Self = Self(4i32);
6017    #[inline]
6018    pub const fn from_raw(value: i32) -> Self {
6019        Self(value)
6020    }
6021    #[inline]
6022    pub const fn as_raw(self) -> i32 {
6023        self.0
6024    }
6025}
6026impl core::fmt::Debug for SamplerAddressMode {
6027    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6028        match self.0 {
6029            0i32 => f.write_str("REPEAT"),
6030            1i32 => f.write_str("MIRRORED_REPEAT"),
6031            2i32 => f.write_str("CLAMP_TO_EDGE"),
6032            3i32 => f.write_str("CLAMP_TO_BORDER"),
6033            4i32 => f.write_str("MIRROR_CLAMP_TO_EDGE"),
6034            other => write!(f, "{}({})", stringify!(SamplerAddressMode), other),
6035        }
6036    }
6037}
6038impl core::fmt::Display for SamplerAddressMode {
6039    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6040        core::fmt::Debug::fmt(self, f)
6041    }
6042}
6043impl core::error::Error for SamplerAddressMode {}
6044///[`VkSamplerMipmapMode`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerMipmapMode.html)
6045#[repr(transparent)]
6046#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6047#[doc(alias = "VkSamplerMipmapMode")]
6048pub struct SamplerMipmapMode(i32);
6049impl SamplerMipmapMode {
6050    ///Choose nearest mip level
6051    pub const NEAREST: Self = Self(0i32);
6052    ///Linear filter between mip levels
6053    pub const LINEAR: Self = Self(1i32);
6054    #[inline]
6055    pub const fn from_raw(value: i32) -> Self {
6056        Self(value)
6057    }
6058    #[inline]
6059    pub const fn as_raw(self) -> i32 {
6060        self.0
6061    }
6062}
6063impl core::fmt::Debug for SamplerMipmapMode {
6064    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6065        match self.0 {
6066            0i32 => f.write_str("NEAREST"),
6067            1i32 => f.write_str("LINEAR"),
6068            other => write!(f, "{}({})", stringify!(SamplerMipmapMode), other),
6069        }
6070    }
6071}
6072impl core::fmt::Display for SamplerMipmapMode {
6073    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6074        core::fmt::Debug::fmt(self, f)
6075    }
6076}
6077impl core::error::Error for SamplerMipmapMode {}
6078///[`VkSamplerReductionMode`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerReductionMode.html)
6079#[repr(transparent)]
6080#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6081#[doc(alias = "VkSamplerReductionMode")]
6082pub struct SamplerReductionMode(i32);
6083impl SamplerReductionMode {
6084    pub const WEIGHTED_AVERAGE: Self = Self(0i32);
6085    pub const MIN: Self = Self(1i32);
6086    pub const MAX: Self = Self(2i32);
6087    pub const WEIGHTED_AVERAGE_RANGECLAMP: Self = Self(1000521000i32);
6088    #[inline]
6089    pub const fn from_raw(value: i32) -> Self {
6090        Self(value)
6091    }
6092    #[inline]
6093    pub const fn as_raw(self) -> i32 {
6094        self.0
6095    }
6096}
6097impl core::fmt::Debug for SamplerReductionMode {
6098    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6099        match self.0 {
6100            0i32 => f.write_str("WEIGHTED_AVERAGE"),
6101            1i32 => f.write_str("MIN"),
6102            2i32 => f.write_str("MAX"),
6103            1000521000i32 => f.write_str("WEIGHTED_AVERAGE_RANGECLAMP"),
6104            other => write!(f, "{}({})", stringify!(SamplerReductionMode), other),
6105        }
6106    }
6107}
6108impl core::fmt::Display for SamplerReductionMode {
6109    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6110        core::fmt::Debug::fmt(self, f)
6111    }
6112}
6113impl core::error::Error for SamplerReductionMode {}
6114///[`VkSamplerYcbcrModelConversion`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrModelConversion.html)
6115#[repr(transparent)]
6116#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6117#[doc(alias = "VkSamplerYcbcrModelConversion")]
6118pub struct SamplerYcbcrModelConversion(i32);
6119impl SamplerYcbcrModelConversion {
6120    pub const RGB_IDENTITY: Self = Self(0i32);
6121    ///just range expansion
6122    pub const YCBCR_IDENTITY: Self = Self(1i32);
6123    ///aka HD YUV
6124    pub const YCBCR_709: Self = Self(2i32);
6125    ///aka SD YUV
6126    pub const YCBCR_601: Self = Self(3i32);
6127    ///aka UHD YUV
6128    pub const YCBCR_2020: Self = Self(4i32);
6129    #[inline]
6130    pub const fn from_raw(value: i32) -> Self {
6131        Self(value)
6132    }
6133    #[inline]
6134    pub const fn as_raw(self) -> i32 {
6135        self.0
6136    }
6137}
6138impl core::fmt::Debug for SamplerYcbcrModelConversion {
6139    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6140        match self.0 {
6141            0i32 => f.write_str("RGB_IDENTITY"),
6142            1i32 => f.write_str("YCBCR_IDENTITY"),
6143            2i32 => f.write_str("YCBCR_709"),
6144            3i32 => f.write_str("YCBCR_601"),
6145            4i32 => f.write_str("YCBCR_2020"),
6146            other => write!(f, "{}({})", stringify!(SamplerYcbcrModelConversion), other),
6147        }
6148    }
6149}
6150impl core::fmt::Display for SamplerYcbcrModelConversion {
6151    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6152        core::fmt::Debug::fmt(self, f)
6153    }
6154}
6155impl core::error::Error for SamplerYcbcrModelConversion {}
6156///[`VkSamplerYcbcrRange`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrRange.html)
6157#[repr(transparent)]
6158#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6159#[doc(alias = "VkSamplerYcbcrRange")]
6160pub struct SamplerYcbcrRange(i32);
6161impl SamplerYcbcrRange {
6162    ///Luma 0..1 maps to 0..255, chroma -0.5..0.5 to 1..255 (clamped)
6163    pub const ITU_FULL: Self = Self(0i32);
6164    ///Luma 0..1 maps to 16..235, chroma -0.5..0.5 to 16..240
6165    pub const ITU_NARROW: Self = Self(1i32);
6166    #[inline]
6167    pub const fn from_raw(value: i32) -> Self {
6168        Self(value)
6169    }
6170    #[inline]
6171    pub const fn as_raw(self) -> i32 {
6172        self.0
6173    }
6174}
6175impl core::fmt::Debug for SamplerYcbcrRange {
6176    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6177        match self.0 {
6178            0i32 => f.write_str("ITU_FULL"),
6179            1i32 => f.write_str("ITU_NARROW"),
6180            other => write!(f, "{}({})", stringify!(SamplerYcbcrRange), other),
6181        }
6182    }
6183}
6184impl core::fmt::Display for SamplerYcbcrRange {
6185    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6186        core::fmt::Debug::fmt(self, f)
6187    }
6188}
6189impl core::error::Error for SamplerYcbcrRange {}
6190///[`VkSciSyncClientTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSciSyncClientTypeNV.html)
6191#[repr(transparent)]
6192#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6193#[doc(alias = "VkSciSyncClientTypeNV")]
6194pub struct SciSyncClientTypeNV(i32);
6195impl SciSyncClientTypeNV {
6196    pub const SIGNALER: Self = Self(0i32);
6197    pub const WAITER: Self = Self(1i32);
6198    pub const SIGNALER_WAITER: Self = Self(2i32);
6199    #[inline]
6200    pub const fn from_raw(value: i32) -> Self {
6201        Self(value)
6202    }
6203    #[inline]
6204    pub const fn as_raw(self) -> i32 {
6205        self.0
6206    }
6207}
6208impl core::fmt::Debug for SciSyncClientTypeNV {
6209    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6210        match self.0 {
6211            0i32 => f.write_str("SIGNALER"),
6212            1i32 => f.write_str("WAITER"),
6213            2i32 => f.write_str("SIGNALER_WAITER"),
6214            other => write!(f, "{}({})", stringify!(SciSyncClientTypeNV), other),
6215        }
6216    }
6217}
6218impl core::fmt::Display for SciSyncClientTypeNV {
6219    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6220        core::fmt::Debug::fmt(self, f)
6221    }
6222}
6223impl core::error::Error for SciSyncClientTypeNV {}
6224///[`VkSciSyncPrimitiveTypeNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSciSyncPrimitiveTypeNV.html)
6225#[repr(transparent)]
6226#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6227#[doc(alias = "VkSciSyncPrimitiveTypeNV")]
6228pub struct SciSyncPrimitiveTypeNV(i32);
6229impl SciSyncPrimitiveTypeNV {
6230    pub const FENCE: Self = Self(0i32);
6231    pub const SEMAPHORE: Self = Self(1i32);
6232    #[inline]
6233    pub const fn from_raw(value: i32) -> Self {
6234        Self(value)
6235    }
6236    #[inline]
6237    pub const fn as_raw(self) -> i32 {
6238        self.0
6239    }
6240}
6241impl core::fmt::Debug for SciSyncPrimitiveTypeNV {
6242    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6243        match self.0 {
6244            0i32 => f.write_str("FENCE"),
6245            1i32 => f.write_str("SEMAPHORE"),
6246            other => write!(f, "{}({})", stringify!(SciSyncPrimitiveTypeNV), other),
6247        }
6248    }
6249}
6250impl core::fmt::Display for SciSyncPrimitiveTypeNV {
6251    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6252        core::fmt::Debug::fmt(self, f)
6253    }
6254}
6255impl core::error::Error for SciSyncPrimitiveTypeNV {}
6256///[`VkScopeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkScopeKHR.html)
6257#[repr(transparent)]
6258#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6259#[doc(alias = "VkScopeKHR")]
6260pub struct ScopeKHR(i32);
6261impl ScopeKHR {
6262    pub const DEVICE: Self = Self(1i32);
6263    pub const WORKGROUP: Self = Self(2i32);
6264    pub const SUBGROUP: Self = Self(3i32);
6265    pub const QUEUE_FAMILY: Self = Self(5i32);
6266    #[inline]
6267    pub const fn from_raw(value: i32) -> Self {
6268        Self(value)
6269    }
6270    #[inline]
6271    pub const fn as_raw(self) -> i32 {
6272        self.0
6273    }
6274}
6275impl core::fmt::Debug for ScopeKHR {
6276    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6277        match self.0 {
6278            1i32 => f.write_str("DEVICE"),
6279            2i32 => f.write_str("WORKGROUP"),
6280            3i32 => f.write_str("SUBGROUP"),
6281            5i32 => f.write_str("QUEUE_FAMILY"),
6282            other => write!(f, "{}({})", stringify!(ScopeKHR), other),
6283        }
6284    }
6285}
6286impl core::fmt::Display for ScopeKHR {
6287    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6288        core::fmt::Debug::fmt(self, f)
6289    }
6290}
6291impl core::error::Error for ScopeKHR {}
6292///[`VkSemaphoreType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreType.html)
6293#[repr(transparent)]
6294#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6295#[doc(alias = "VkSemaphoreType")]
6296pub struct SemaphoreType(i32);
6297impl SemaphoreType {
6298    pub const BINARY: Self = Self(0i32);
6299    pub const TIMELINE: Self = Self(1i32);
6300    #[inline]
6301    pub const fn from_raw(value: i32) -> Self {
6302        Self(value)
6303    }
6304    #[inline]
6305    pub const fn as_raw(self) -> i32 {
6306        self.0
6307    }
6308}
6309impl core::fmt::Debug for SemaphoreType {
6310    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6311        match self.0 {
6312            0i32 => f.write_str("BINARY"),
6313            1i32 => f.write_str("TIMELINE"),
6314            other => write!(f, "{}({})", stringify!(SemaphoreType), other),
6315        }
6316    }
6317}
6318impl core::fmt::Display for SemaphoreType {
6319    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6320        core::fmt::Debug::fmt(self, f)
6321    }
6322}
6323impl core::error::Error for SemaphoreType {}
6324///[`VkShaderCodeTypeEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCodeTypeEXT.html)
6325#[repr(transparent)]
6326#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6327#[doc(alias = "VkShaderCodeTypeEXT")]
6328pub struct ShaderCodeTypeEXT(i32);
6329impl ShaderCodeTypeEXT {
6330    pub const BINARY: Self = Self(0i32);
6331    pub const SPIRV: Self = Self(1i32);
6332    #[inline]
6333    pub const fn from_raw(value: i32) -> Self {
6334        Self(value)
6335    }
6336    #[inline]
6337    pub const fn as_raw(self) -> i32 {
6338        self.0
6339    }
6340}
6341impl core::fmt::Debug for ShaderCodeTypeEXT {
6342    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6343        match self.0 {
6344            0i32 => f.write_str("BINARY"),
6345            1i32 => f.write_str("SPIRV"),
6346            other => write!(f, "{}({})", stringify!(ShaderCodeTypeEXT), other),
6347        }
6348    }
6349}
6350impl core::fmt::Display for ShaderCodeTypeEXT {
6351    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6352        core::fmt::Debug::fmt(self, f)
6353    }
6354}
6355impl core::error::Error for ShaderCodeTypeEXT {}
6356///[`VkShaderFloatControlsIndependence`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderFloatControlsIndependence.html)
6357#[repr(transparent)]
6358#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6359#[doc(alias = "VkShaderFloatControlsIndependence")]
6360pub struct ShaderFloatControlsIndependence(i32);
6361impl ShaderFloatControlsIndependence {
6362    pub const _32_BIT_ONLY: Self = Self(0i32);
6363    pub const ALL: Self = Self(1i32);
6364    pub const NONE: Self = Self(2i32);
6365    #[inline]
6366    pub const fn from_raw(value: i32) -> Self {
6367        Self(value)
6368    }
6369    #[inline]
6370    pub const fn as_raw(self) -> i32 {
6371        self.0
6372    }
6373}
6374impl core::fmt::Debug for ShaderFloatControlsIndependence {
6375    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6376        match self.0 {
6377            0i32 => f.write_str("_32_BIT_ONLY"),
6378            1i32 => f.write_str("ALL"),
6379            2i32 => f.write_str("NONE"),
6380            other => {
6381                write!(f, "{}({})", stringify!(ShaderFloatControlsIndependence), other)
6382            }
6383        }
6384    }
6385}
6386impl core::fmt::Display for ShaderFloatControlsIndependence {
6387    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6388        core::fmt::Debug::fmt(self, f)
6389    }
6390}
6391impl core::error::Error for ShaderFloatControlsIndependence {}
6392///[`VkShaderGroupShaderKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderGroupShaderKHR.html)
6393#[repr(transparent)]
6394#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6395#[doc(alias = "VkShaderGroupShaderKHR")]
6396pub struct ShaderGroupShaderKHR(i32);
6397impl ShaderGroupShaderKHR {
6398    pub const GENERAL: Self = Self(0i32);
6399    pub const CLOSEST_HIT: Self = Self(1i32);
6400    pub const ANY_HIT: Self = Self(2i32);
6401    pub const INTERSECTION: Self = Self(3i32);
6402    #[inline]
6403    pub const fn from_raw(value: i32) -> Self {
6404        Self(value)
6405    }
6406    #[inline]
6407    pub const fn as_raw(self) -> i32 {
6408        self.0
6409    }
6410}
6411impl core::fmt::Debug for ShaderGroupShaderKHR {
6412    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6413        match self.0 {
6414            0i32 => f.write_str("GENERAL"),
6415            1i32 => f.write_str("CLOSEST_HIT"),
6416            2i32 => f.write_str("ANY_HIT"),
6417            3i32 => f.write_str("INTERSECTION"),
6418            other => write!(f, "{}({})", stringify!(ShaderGroupShaderKHR), other),
6419        }
6420    }
6421}
6422impl core::fmt::Display for ShaderGroupShaderKHR {
6423    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6424        core::fmt::Debug::fmt(self, f)
6425    }
6426}
6427impl core::error::Error for ShaderGroupShaderKHR {}
6428///[`VkShaderInfoTypeAMD`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderInfoTypeAMD.html)
6429#[repr(transparent)]
6430#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6431#[doc(alias = "VkShaderInfoTypeAMD")]
6432pub struct ShaderInfoTypeAMD(i32);
6433impl ShaderInfoTypeAMD {
6434    pub const STATISTICS: Self = Self(0i32);
6435    pub const BINARY: Self = Self(1i32);
6436    pub const DISASSEMBLY: Self = Self(2i32);
6437    #[inline]
6438    pub const fn from_raw(value: i32) -> Self {
6439        Self(value)
6440    }
6441    #[inline]
6442    pub const fn as_raw(self) -> i32 {
6443        self.0
6444    }
6445}
6446impl core::fmt::Debug for ShaderInfoTypeAMD {
6447    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6448        match self.0 {
6449            0i32 => f.write_str("STATISTICS"),
6450            1i32 => f.write_str("BINARY"),
6451            2i32 => f.write_str("DISASSEMBLY"),
6452            other => write!(f, "{}({})", stringify!(ShaderInfoTypeAMD), other),
6453        }
6454    }
6455}
6456impl core::fmt::Display for ShaderInfoTypeAMD {
6457    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6458        core::fmt::Debug::fmt(self, f)
6459    }
6460}
6461impl core::error::Error for ShaderInfoTypeAMD {}
6462///[`VkShadingRatePaletteEntryNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkShadingRatePaletteEntryNV.html)
6463#[repr(transparent)]
6464#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6465#[doc(alias = "VkShadingRatePaletteEntryNV")]
6466pub struct ShadingRatePaletteEntryNV(i32);
6467impl ShadingRatePaletteEntryNV {
6468    pub const NO_INVOCATIONS: Self = Self(0i32);
6469    pub const _16_INVOCATIONS_PER_PIXEL: Self = Self(1i32);
6470    pub const _8_INVOCATIONS_PER_PIXEL: Self = Self(2i32);
6471    pub const _4_INVOCATIONS_PER_PIXEL: Self = Self(3i32);
6472    pub const _2_INVOCATIONS_PER_PIXEL: Self = Self(4i32);
6473    pub const _1_INVOCATION_PER_PIXEL: Self = Self(5i32);
6474    pub const _1_INVOCATION_PER_2X1_PIXELS: Self = Self(6i32);
6475    pub const _1_INVOCATION_PER_1X2_PIXELS: Self = Self(7i32);
6476    pub const _1_INVOCATION_PER_2X2_PIXELS: Self = Self(8i32);
6477    pub const _1_INVOCATION_PER_4X2_PIXELS: Self = Self(9i32);
6478    pub const _1_INVOCATION_PER_2X4_PIXELS: Self = Self(10i32);
6479    pub const _1_INVOCATION_PER_4X4_PIXELS: Self = Self(11i32);
6480    #[inline]
6481    pub const fn from_raw(value: i32) -> Self {
6482        Self(value)
6483    }
6484    #[inline]
6485    pub const fn as_raw(self) -> i32 {
6486        self.0
6487    }
6488}
6489impl core::fmt::Debug for ShadingRatePaletteEntryNV {
6490    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6491        match self.0 {
6492            0i32 => f.write_str("NO_INVOCATIONS"),
6493            1i32 => f.write_str("_16_INVOCATIONS_PER_PIXEL"),
6494            2i32 => f.write_str("_8_INVOCATIONS_PER_PIXEL"),
6495            3i32 => f.write_str("_4_INVOCATIONS_PER_PIXEL"),
6496            4i32 => f.write_str("_2_INVOCATIONS_PER_PIXEL"),
6497            5i32 => f.write_str("_1_INVOCATION_PER_PIXEL"),
6498            6i32 => f.write_str("_1_INVOCATION_PER_2X1_PIXELS"),
6499            7i32 => f.write_str("_1_INVOCATION_PER_1X2_PIXELS"),
6500            8i32 => f.write_str("_1_INVOCATION_PER_2X2_PIXELS"),
6501            9i32 => f.write_str("_1_INVOCATION_PER_4X2_PIXELS"),
6502            10i32 => f.write_str("_1_INVOCATION_PER_2X4_PIXELS"),
6503            11i32 => f.write_str("_1_INVOCATION_PER_4X4_PIXELS"),
6504            other => write!(f, "{}({})", stringify!(ShadingRatePaletteEntryNV), other),
6505        }
6506    }
6507}
6508impl core::fmt::Display for ShadingRatePaletteEntryNV {
6509    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6510        core::fmt::Debug::fmt(self, f)
6511    }
6512}
6513impl core::error::Error for ShadingRatePaletteEntryNV {}
6514///[`VkSharingMode`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSharingMode.html)
6515#[repr(transparent)]
6516#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6517#[doc(alias = "VkSharingMode")]
6518pub struct SharingMode(i32);
6519impl SharingMode {
6520    pub const EXCLUSIVE: Self = Self(0i32);
6521    pub const CONCURRENT: Self = Self(1i32);
6522    #[inline]
6523    pub const fn from_raw(value: i32) -> Self {
6524        Self(value)
6525    }
6526    #[inline]
6527    pub const fn as_raw(self) -> i32 {
6528        self.0
6529    }
6530}
6531impl core::fmt::Debug for SharingMode {
6532    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6533        match self.0 {
6534            0i32 => f.write_str("EXCLUSIVE"),
6535            1i32 => f.write_str("CONCURRENT"),
6536            other => write!(f, "{}({})", stringify!(SharingMode), other),
6537        }
6538    }
6539}
6540impl core::fmt::Display for SharingMode {
6541    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6542        core::fmt::Debug::fmt(self, f)
6543    }
6544}
6545impl core::error::Error for SharingMode {}
6546///[`VkStencilOp`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilOp.html)
6547#[repr(transparent)]
6548#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6549#[doc(alias = "VkStencilOp")]
6550pub struct StencilOp(i32);
6551impl StencilOp {
6552    pub const KEEP: Self = Self(0i32);
6553    pub const ZERO: Self = Self(1i32);
6554    pub const REPLACE: Self = Self(2i32);
6555    pub const INCREMENT_AND_CLAMP: Self = Self(3i32);
6556    pub const DECREMENT_AND_CLAMP: Self = Self(4i32);
6557    pub const INVERT: Self = Self(5i32);
6558    pub const INCREMENT_AND_WRAP: Self = Self(6i32);
6559    pub const DECREMENT_AND_WRAP: Self = Self(7i32);
6560    #[inline]
6561    pub const fn from_raw(value: i32) -> Self {
6562        Self(value)
6563    }
6564    #[inline]
6565    pub const fn as_raw(self) -> i32 {
6566        self.0
6567    }
6568}
6569impl core::fmt::Debug for StencilOp {
6570    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6571        match self.0 {
6572            0i32 => f.write_str("KEEP"),
6573            1i32 => f.write_str("ZERO"),
6574            2i32 => f.write_str("REPLACE"),
6575            3i32 => f.write_str("INCREMENT_AND_CLAMP"),
6576            4i32 => f.write_str("DECREMENT_AND_CLAMP"),
6577            5i32 => f.write_str("INVERT"),
6578            6i32 => f.write_str("INCREMENT_AND_WRAP"),
6579            7i32 => f.write_str("DECREMENT_AND_WRAP"),
6580            other => write!(f, "{}({})", stringify!(StencilOp), other),
6581        }
6582    }
6583}
6584impl core::fmt::Display for StencilOp {
6585    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
6586        core::fmt::Debug::fmt(self, f)
6587    }
6588}
6589impl core::error::Error for StencilOp {}
6590///[`VkStructureType`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkStructureType.html)
6591#[repr(transparent)]
6592#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
6593#[doc(alias = "VkStructureType")]
6594pub struct StructureType(i32);
6595impl StructureType {
6596    pub const APPLICATION_INFO: Self = Self(0i32);
6597    pub const INSTANCE_CREATE_INFO: Self = Self(1i32);
6598    pub const DEVICE_QUEUE_CREATE_INFO: Self = Self(2i32);
6599    pub const DEVICE_CREATE_INFO: Self = Self(3i32);
6600    pub const SUBMIT_INFO: Self = Self(4i32);
6601    pub const MEMORY_ALLOCATE_INFO: Self = Self(5i32);
6602    pub const MAPPED_MEMORY_RANGE: Self = Self(6i32);
6603    pub const BIND_SPARSE_INFO: Self = Self(7i32);
6604    pub const FENCE_CREATE_INFO: Self = Self(8i32);
6605    pub const SEMAPHORE_CREATE_INFO: Self = Self(9i32);
6606    pub const EVENT_CREATE_INFO: Self = Self(10i32);
6607    pub const QUERY_POOL_CREATE_INFO: Self = Self(11i32);
6608    pub const BUFFER_CREATE_INFO: Self = Self(12i32);
6609    pub const BUFFER_VIEW_CREATE_INFO: Self = Self(13i32);
6610    pub const IMAGE_CREATE_INFO: Self = Self(14i32);
6611    pub const IMAGE_VIEW_CREATE_INFO: Self = Self(15i32);
6612    pub const SHADER_MODULE_CREATE_INFO: Self = Self(16i32);
6613    pub const PIPELINE_CACHE_CREATE_INFO: Self = Self(17i32);
6614    pub const PIPELINE_SHADER_STAGE_CREATE_INFO: Self = Self(18i32);
6615    pub const PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: Self = Self(19i32);
6616    pub const PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: Self = Self(20i32);
6617    pub const PIPELINE_TESSELLATION_STATE_CREATE_INFO: Self = Self(21i32);
6618    pub const PIPELINE_VIEWPORT_STATE_CREATE_INFO: Self = Self(22i32);
6619    pub const PIPELINE_RASTERIZATION_STATE_CREATE_INFO: Self = Self(23i32);
6620    pub const PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: Self = Self(24i32);
6621    pub const PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: Self = Self(25i32);
6622    pub const PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: Self = Self(26i32);
6623    pub const PIPELINE_DYNAMIC_STATE_CREATE_INFO: Self = Self(27i32);
6624    pub const GRAPHICS_PIPELINE_CREATE_INFO: Self = Self(28i32);
6625    pub const COMPUTE_PIPELINE_CREATE_INFO: Self = Self(29i32);
6626    pub const PIPELINE_LAYOUT_CREATE_INFO: Self = Self(30i32);
6627    pub const SAMPLER_CREATE_INFO: Self = Self(31i32);
6628    pub const DESCRIPTOR_SET_LAYOUT_CREATE_INFO: Self = Self(32i32);
6629    pub const DESCRIPTOR_POOL_CREATE_INFO: Self = Self(33i32);
6630    pub const DESCRIPTOR_SET_ALLOCATE_INFO: Self = Self(34i32);
6631    pub const WRITE_DESCRIPTOR_SET: Self = Self(35i32);
6632    pub const COPY_DESCRIPTOR_SET: Self = Self(36i32);
6633    pub const FRAMEBUFFER_CREATE_INFO: Self = Self(37i32);
6634    pub const RENDER_PASS_CREATE_INFO: Self = Self(38i32);
6635    pub const COMMAND_POOL_CREATE_INFO: Self = Self(39i32);
6636    pub const COMMAND_BUFFER_ALLOCATE_INFO: Self = Self(40i32);
6637    pub const COMMAND_BUFFER_INHERITANCE_INFO: Self = Self(41i32);
6638    pub const COMMAND_BUFFER_BEGIN_INFO: Self = Self(42i32);
6639    pub const RENDER_PASS_BEGIN_INFO: Self = Self(43i32);
6640    pub const BUFFER_MEMORY_BARRIER: Self = Self(44i32);
6641    pub const IMAGE_MEMORY_BARRIER: Self = Self(45i32);
6642    pub const MEMORY_BARRIER: Self = Self(46i32);
6643    ///Reserved for internal use by the loader, layers, and ICDs
6644    pub const LOADER_INSTANCE_CREATE_INFO: Self = Self(47i32);
6645    ///Reserved for internal use by the loader, layers, and ICDs
6646    pub const LOADER_DEVICE_CREATE_INFO: Self = Self(48i32);
6647    pub const BIND_BUFFER_MEMORY_INFO: Self = Self(1000157000i32);
6648    pub const BIND_IMAGE_MEMORY_INFO: Self = Self(1000157001i32);
6649    pub const MEMORY_DEDICATED_REQUIREMENTS: Self = Self(1000127000i32);
6650    pub const MEMORY_DEDICATED_ALLOCATE_INFO: Self = Self(1000127001i32);
6651    pub const MEMORY_ALLOCATE_FLAGS_INFO: Self = Self(1000060000i32);
6652    pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: Self = Self(1000060004i32);
6653    pub const DEVICE_GROUP_SUBMIT_INFO: Self = Self(1000060005i32);
6654    pub const DEVICE_GROUP_BIND_SPARSE_INFO: Self = Self(1000060006i32);
6655    pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: Self = Self(1000060013i32);
6656    pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: Self = Self(1000060014i32);
6657    pub const PHYSICAL_DEVICE_GROUP_PROPERTIES: Self = Self(1000070000i32);
6658    pub const DEVICE_GROUP_DEVICE_CREATE_INFO: Self = Self(1000070001i32);
6659    pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1000146000i32);
6660    pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1000146001i32);
6661    pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: Self = Self(1000146002i32);
6662    pub const MEMORY_REQUIREMENTS_2: Self = Self(1000146003i32);
6663    pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: Self = Self(1000146004i32);
6664    pub const PHYSICAL_DEVICE_FEATURES_2: Self = Self(1000059000i32);
6665    pub const PHYSICAL_DEVICE_PROPERTIES_2: Self = Self(1000059001i32);
6666    pub const FORMAT_PROPERTIES_2: Self = Self(1000059002i32);
6667    pub const IMAGE_FORMAT_PROPERTIES_2: Self = Self(1000059003i32);
6668    pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: Self = Self(1000059004i32);
6669    pub const QUEUE_FAMILY_PROPERTIES_2: Self = Self(1000059005i32);
6670    pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: Self = Self(1000059006i32);
6671    pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2: Self = Self(1000059007i32);
6672    pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: Self = Self(1000059008i32);
6673    pub const IMAGE_VIEW_USAGE_CREATE_INFO: Self = Self(1000117002i32);
6674    pub const PROTECTED_SUBMIT_INFO: Self = Self(1000145000i32);
6675    pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: Self = Self(1000145001i32);
6676    pub const PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: Self = Self(1000145002i32);
6677    pub const DEVICE_QUEUE_INFO_2: Self = Self(1000145003i32);
6678    pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: Self = Self(1000071000i32);
6679    pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES: Self = Self(1000071001i32);
6680    pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: Self = Self(1000071002i32);
6681    pub const EXTERNAL_BUFFER_PROPERTIES: Self = Self(1000071003i32);
6682    pub const PHYSICAL_DEVICE_ID_PROPERTIES: Self = Self(1000071004i32);
6683    pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO: Self = Self(1000072000i32);
6684    pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO: Self = Self(1000072001i32);
6685    pub const EXPORT_MEMORY_ALLOCATE_INFO: Self = Self(1000072002i32);
6686    pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: Self = Self(1000112000i32);
6687    pub const EXTERNAL_FENCE_PROPERTIES: Self = Self(1000112001i32);
6688    pub const EXPORT_FENCE_CREATE_INFO: Self = Self(1000113000i32);
6689    pub const EXPORT_SEMAPHORE_CREATE_INFO: Self = Self(1000077000i32);
6690    pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: Self = Self(1000076000i32);
6691    pub const EXTERNAL_SEMAPHORE_PROPERTIES: Self = Self(1000076001i32);
6692    pub const PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: Self = Self(1000094000i32);
6693    pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: Self = Self(1000083000i32);
6694    pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: Self = Self(1000120000i32);
6695    pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: Self = Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
6696    pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: Self = Self(1000085000i32);
6697    pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: Self = Self(1000168000i32);
6698    pub const DESCRIPTOR_SET_LAYOUT_SUPPORT: Self = Self(1000168001i32);
6699    pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO: Self = Self(1000156000i32);
6700    pub const SAMPLER_YCBCR_CONVERSION_INFO: Self = Self(1000156001i32);
6701    pub const BIND_IMAGE_PLANE_MEMORY_INFO: Self = Self(1000156002i32);
6702    pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: Self = Self(1000156003i32);
6703    pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: Self = Self(
6704        1000156004i32,
6705    );
6706    pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: Self = Self(
6707        1000156005i32,
6708    );
6709    pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: Self = Self(1000060003i32);
6710    pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: Self = Self(1000117000i32);
6711    pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: Self = Self(
6712        1000117001i32,
6713    );
6714    pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: Self = Self(
6715        1000117003i32,
6716    );
6717    pub const RENDER_PASS_MULTIVIEW_CREATE_INFO: Self = Self(1000053000i32);
6718    pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES: Self = Self(1000053001i32);
6719    pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: Self = Self(1000053002i32);
6720    pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: Self = Self(
6721        1000063000i32,
6722    );
6723    pub const PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: Self = Self::PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
6724    pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES: Self = Self(1000196000i32);
6725    pub const PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: Self = Self(49i32);
6726    pub const PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: Self = Self(50i32);
6727    pub const PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: Self = Self(51i32);
6728    pub const PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: Self = Self(52i32);
6729    pub const IMAGE_FORMAT_LIST_CREATE_INFO: Self = Self(1000147000i32);
6730    pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: Self = Self(1000211000i32);
6731    pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: Self = Self(1000261000i32);
6732    pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: Self = Self(1000207000i32);
6733    pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: Self = Self(1000207001i32);
6734    pub const SEMAPHORE_TYPE_CREATE_INFO: Self = Self(1000207002i32);
6735    pub const TIMELINE_SEMAPHORE_SUBMIT_INFO: Self = Self(1000207003i32);
6736    pub const SEMAPHORE_WAIT_INFO: Self = Self(1000207004i32);
6737    pub const SEMAPHORE_SIGNAL_INFO: Self = Self(1000207005i32);
6738    pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: Self = Self(1000257000i32);
6739    pub const BUFFER_DEVICE_ADDRESS_INFO: Self = Self(1000244001i32);
6740    pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: Self = Self(1000257002i32);
6741    pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: Self = Self(1000257003i32);
6742    pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: Self = Self(1000257004i32);
6743    pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: Self = Self(1000177000i32);
6744    pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: Self = Self(1000180000i32);
6745    pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: Self = Self(1000082000i32);
6746    pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: Self = Self(1000197000i32);
6747    pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: Self = Self(
6748        1000161000i32,
6749    );
6750    pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: Self = Self(1000161001i32);
6751    pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: Self = Self(1000161002i32);
6752    pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: Self = Self(
6753        1000161003i32,
6754    );
6755    pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: Self = Self(
6756        1000161004i32,
6757    );
6758    pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: Self = Self(1000221000i32);
6759    pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: Self = Self(
6760        1000130000i32,
6761    );
6762    pub const SAMPLER_REDUCTION_MODE_CREATE_INFO: Self = Self(1000130001i32);
6763    pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: Self = Self(
6764        1000253000i32,
6765    );
6766    pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: Self = Self(
6767        1000175000i32,
6768    );
6769    pub const ATTACHMENT_DESCRIPTION_2: Self = Self(1000109000i32);
6770    pub const ATTACHMENT_REFERENCE_2: Self = Self(1000109001i32);
6771    pub const SUBPASS_DESCRIPTION_2: Self = Self(1000109002i32);
6772    pub const SUBPASS_DEPENDENCY_2: Self = Self(1000109003i32);
6773    pub const RENDER_PASS_CREATE_INFO_2: Self = Self(1000109004i32);
6774    pub const SUBPASS_BEGIN_INFO: Self = Self(1000109005i32);
6775    pub const SUBPASS_END_INFO: Self = Self(1000109006i32);
6776    pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: Self = Self(
6777        1000199000i32,
6778    );
6779    pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: Self = Self(1000199001i32);
6780    pub const IMAGE_STENCIL_USAGE_CREATE_INFO: Self = Self(1000246000i32);
6781    pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: Self = Self(1000108000i32);
6782    pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: Self = Self(1000108001i32);
6783    pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: Self = Self(1000108002i32);
6784    pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO: Self = Self(1000108003i32);
6785    pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: Self = Self(
6786        1000241000i32,
6787    );
6788    pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT: Self = Self(1000241001i32);
6789    pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: Self = Self(1000241002i32);
6790    pub const PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: Self = Self(53i32);
6791    pub const PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: Self = Self(54i32);
6792    pub const PHYSICAL_DEVICE_TOOL_PROPERTIES: Self = Self(1000245000i32);
6793    pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: Self = Self(1000295000i32);
6794    pub const DEVICE_PRIVATE_DATA_CREATE_INFO: Self = Self(1000295001i32);
6795    pub const PRIVATE_DATA_SLOT_CREATE_INFO: Self = Self(1000295002i32);
6796    pub const MEMORY_BARRIER_2: Self = Self(1000314000i32);
6797    pub const BUFFER_MEMORY_BARRIER_2: Self = Self(1000314001i32);
6798    pub const IMAGE_MEMORY_BARRIER_2: Self = Self(1000314002i32);
6799    pub const DEPENDENCY_INFO: Self = Self(1000314003i32);
6800    pub const SUBMIT_INFO_2: Self = Self(1000314004i32);
6801    pub const SEMAPHORE_SUBMIT_INFO: Self = Self(1000314005i32);
6802    pub const COMMAND_BUFFER_SUBMIT_INFO: Self = Self(1000314006i32);
6803    pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: Self = Self(1000314007i32);
6804    pub const COPY_BUFFER_INFO_2: Self = Self(1000337000i32);
6805    pub const COPY_IMAGE_INFO_2: Self = Self(1000337001i32);
6806    pub const COPY_BUFFER_TO_IMAGE_INFO_2: Self = Self(1000337002i32);
6807    pub const COPY_IMAGE_TO_BUFFER_INFO_2: Self = Self(1000337003i32);
6808    pub const BUFFER_COPY_2: Self = Self(1000337006i32);
6809    pub const IMAGE_COPY_2: Self = Self(1000337007i32);
6810    pub const BUFFER_IMAGE_COPY_2: Self = Self(1000337009i32);
6811    pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: Self = Self(
6812        1000066000i32,
6813    );
6814    pub const FORMAT_PROPERTIES_3: Self = Self(1000360000i32);
6815    pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: Self = Self(1000413000i32);
6816    pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: Self = Self(1000413001i32);
6817    pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS: Self = Self(1000413002i32);
6818    pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS: Self = Self(1000413003i32);
6819    pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO: Self = Self(1000192000i32);
6820    pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: Self = Self(
6821        1000215000i32,
6822    );
6823    pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: Self = Self(
6824        1000276000i32,
6825    );
6826    pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: Self = Self(
6827        1000297000i32,
6828    );
6829    pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: Self = Self(
6830        1000325000i32,
6831    );
6832    pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: Self = Self(1000335000i32);
6833    pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: Self = Self(
6834        1000225000i32,
6835    );
6836    pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: Self = Self(
6837        1000225001i32,
6838    );
6839    pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: Self = Self(1000225002i32);
6840    pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: Self = Self(1000138000i32);
6841    pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: Self = Self(
6842        1000138001i32,
6843    );
6844    pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: Self = Self(1000138002i32);
6845    pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: Self = Self(
6846        1000138003i32,
6847    );
6848    pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: Self = Self(
6849        1000280000i32,
6850    );
6851    pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: Self = Self(
6852        1000280001i32,
6853    );
6854    pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: Self = Self(
6855        1000281001i32,
6856    );
6857    pub const BLIT_IMAGE_INFO_2: Self = Self(1000337004i32);
6858    pub const RESOLVE_IMAGE_INFO_2: Self = Self(1000337005i32);
6859    pub const IMAGE_BLIT_2: Self = Self(1000337008i32);
6860    pub const IMAGE_RESOLVE_2: Self = Self(1000337010i32);
6861    pub const RENDERING_INFO: Self = Self(1000044000i32);
6862    pub const RENDERING_ATTACHMENT_INFO: Self = Self(1000044001i32);
6863    pub const PIPELINE_RENDERING_CREATE_INFO: Self = Self(1000044002i32);
6864    pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: Self = Self(1000044003i32);
6865    pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: Self = Self(1000044004i32);
6866    pub const PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: Self = Self(55i32);
6867    pub const PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: Self = Self(56i32);
6868    pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: Self = Self(1000174000i32);
6869    pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: Self = Self(1000388000i32);
6870    pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: Self = Self(1000388001i32);
6871    pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: Self = Self(1000265000i32);
6872    pub const MEMORY_MAP_INFO: Self = Self(1000271000i32);
6873    pub const MEMORY_UNMAP_INFO: Self = Self(1000271001i32);
6874    pub const PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: Self = Self(1000470000i32);
6875    pub const PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: Self = Self(1000470001i32);
6876    pub const DEVICE_IMAGE_SUBRESOURCE_INFO: Self = Self(1000470004i32);
6877    pub const SUBRESOURCE_LAYOUT_2: Self = Self(1000338002i32);
6878    pub const IMAGE_SUBRESOURCE_2: Self = Self(1000338003i32);
6879    pub const BUFFER_USAGE_FLAGS_2_CREATE_INFO: Self = Self(1000470006i32);
6880    pub const PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: Self = Self(1000545000i32);
6881    pub const PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: Self = Self(1000545001i32);
6882    pub const BIND_MEMORY_STATUS: Self = Self(1000545002i32);
6883    pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: Self = Self(1000270000i32);
6884    pub const PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: Self = Self(1000270001i32);
6885    pub const MEMORY_TO_IMAGE_COPY: Self = Self(1000270002i32);
6886    pub const IMAGE_TO_MEMORY_COPY: Self = Self(1000270003i32);
6887    pub const COPY_IMAGE_TO_MEMORY_INFO: Self = Self(1000270004i32);
6888    pub const COPY_MEMORY_TO_IMAGE_INFO: Self = Self(1000270005i32);
6889    pub const HOST_IMAGE_LAYOUT_TRANSITION_INFO: Self = Self(1000270006i32);
6890    pub const COPY_IMAGE_TO_IMAGE_INFO: Self = Self(1000270007i32);
6891    pub const SUBRESOURCE_HOST_MEMCPY_SIZE: Self = Self(1000270008i32);
6892    pub const HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: Self = Self(1000270009i32);
6893    pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: Self = Self(
6894        1000416000i32,
6895    );
6896    pub const PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: Self = Self(
6897        1000528000i32,
6898    );
6899    pub const PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: Self = Self(1000544000i32);
6900    pub const PIPELINE_CREATE_FLAGS_2_CREATE_INFO: Self = Self(1000470005i32);
6901    pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: Self = Self(1000080000i32);
6902    pub const BIND_DESCRIPTOR_SETS_INFO: Self = Self(1000545003i32);
6903    pub const PUSH_CONSTANTS_INFO: Self = Self(1000545004i32);
6904    pub const PUSH_DESCRIPTOR_SET_INFO: Self = Self(1000545005i32);
6905    pub const PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: Self = Self(1000545006i32);
6906    pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: Self = Self(
6907        1000466000i32,
6908    );
6909    pub const PIPELINE_ROBUSTNESS_CREATE_INFO: Self = Self(1000068000i32);
6910    pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: Self = Self(1000068001i32);
6911    pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: Self = Self(1000068002i32);
6912    pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: Self = Self(1000259000i32);
6913    pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: Self = Self(1000259001i32);
6914    pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: Self = Self(1000259002i32);
6915    pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: Self = Self(
6916        1000525000i32,
6917    );
6918    pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: Self = Self(
6919        1000190001i32,
6920    );
6921    pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: Self = Self(
6922        1000190002i32,
6923    );
6924    pub const RENDERING_AREA_INFO: Self = Self(1000470003i32);
6925    pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: Self = Self(
6926        1000232000i32,
6927    );
6928    pub const RENDERING_ATTACHMENT_LOCATION_INFO: Self = Self(1000232001i32);
6929    pub const RENDERING_INPUT_ATTACHMENT_INDEX_INFO: Self = Self(1000232002i32);
6930    pub const PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES: Self = Self(1000298000i32);
6931    pub const PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES: Self = Self(1000298001i32);
6932    pub const DEVICE_OBJECT_RESERVATION_CREATE_INFO: Self = Self(1000298002i32);
6933    pub const COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO: Self = Self(1000298003i32);
6934    pub const COMMAND_POOL_MEMORY_CONSUMPTION: Self = Self(1000298004i32);
6935    pub const PIPELINE_POOL_SIZE: Self = Self(1000298005i32);
6936    pub const FAULT_DATA: Self = Self(1000298007i32);
6937    pub const FAULT_CALLBACK_INFO: Self = Self(1000298008i32);
6938    pub const PIPELINE_OFFLINE_CREATE_INFO: Self = Self(1000298010i32);
6939    pub const SWAPCHAIN_CREATE_INFO: Self = Self(1000001000i32);
6940    pub const PRESENT_INFO: Self = Self(1000001001i32);
6941    pub const DEVICE_GROUP_PRESENT_CAPABILITIES: Self = Self(1000060007i32);
6942    pub const IMAGE_SWAPCHAIN_CREATE_INFO: Self = Self(1000060008i32);
6943    pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO: Self = Self(1000060009i32);
6944    pub const ACQUIRE_NEXT_IMAGE_INFO: Self = Self(1000060010i32);
6945    pub const DEVICE_GROUP_PRESENT_INFO: Self = Self(1000060011i32);
6946    pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO: Self = Self(1000060012i32);
6947    pub const DISPLAY_MODE_CREATE_INFO: Self = Self(1000002000i32);
6948    pub const DISPLAY_SURFACE_CREATE_INFO: Self = Self(1000002001i32);
6949    pub const DISPLAY_PRESENT_INFO: Self = Self(1000003000i32);
6950    pub const XLIB_SURFACE_CREATE_INFO: Self = Self(1000004000i32);
6951    pub const XCB_SURFACE_CREATE_INFO: Self = Self(1000005000i32);
6952    pub const WAYLAND_SURFACE_CREATE_INFO: Self = Self(1000006000i32);
6953    pub const ANDROID_SURFACE_CREATE_INFO: Self = Self(1000008000i32);
6954    pub const WIN32_SURFACE_CREATE_INFO: Self = Self(1000009000i32);
6955    pub const DEBUG_REPORT_CALLBACK_CREATE_INFO: Self = Self(1000011000i32);
6956    pub const DEBUG_REPORT_CREATE_INFO: Self = Self::DEBUG_REPORT_CALLBACK_CREATE_INFO;
6957    pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER: Self = Self(
6958        1000018000i32,
6959    );
6960    pub const DEBUG_MARKER_OBJECT_NAME_INFO: Self = Self(1000022000i32);
6961    pub const DEBUG_MARKER_OBJECT_TAG_INFO: Self = Self(1000022001i32);
6962    pub const DEBUG_MARKER_MARKER_INFO: Self = Self(1000022002i32);
6963    pub const VIDEO_PROFILE_INFO: Self = Self(1000023000i32);
6964    pub const VIDEO_CAPABILITIES: Self = Self(1000023001i32);
6965    pub const VIDEO_PICTURE_RESOURCE_INFO: Self = Self(1000023002i32);
6966    pub const VIDEO_SESSION_MEMORY_REQUIREMENTS: Self = Self(1000023003i32);
6967    pub const BIND_VIDEO_SESSION_MEMORY_INFO: Self = Self(1000023004i32);
6968    pub const VIDEO_SESSION_CREATE_INFO: Self = Self(1000023005i32);
6969    pub const VIDEO_SESSION_PARAMETERS_CREATE_INFO: Self = Self(1000023006i32);
6970    pub const VIDEO_SESSION_PARAMETERS_UPDATE_INFO: Self = Self(1000023007i32);
6971    pub const VIDEO_BEGIN_CODING_INFO: Self = Self(1000023008i32);
6972    pub const VIDEO_END_CODING_INFO: Self = Self(1000023009i32);
6973    pub const VIDEO_CODING_CONTROL_INFO: Self = Self(1000023010i32);
6974    pub const VIDEO_REFERENCE_SLOT_INFO: Self = Self(1000023011i32);
6975    pub const QUEUE_FAMILY_VIDEO_PROPERTIES: Self = Self(1000023012i32);
6976    pub const VIDEO_PROFILE_LIST_INFO: Self = Self(1000023013i32);
6977    pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO: Self = Self(1000023014i32);
6978    pub const VIDEO_FORMAT_PROPERTIES: Self = Self(1000023015i32);
6979    pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES: Self = Self(1000023016i32);
6980    pub const VIDEO_DECODE_INFO: Self = Self(1000024000i32);
6981    pub const VIDEO_DECODE_CAPABILITIES: Self = Self(1000024001i32);
6982    pub const VIDEO_DECODE_USAGE_INFO: Self = Self(1000024002i32);
6983    pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO: Self = Self(1000026000i32);
6984    pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO: Self = Self(1000026001i32);
6985    pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO: Self = Self(1000026002i32);
6986    pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES: Self = Self(1000028000i32);
6987    pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES: Self = Self(1000028001i32);
6988    pub const PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO: Self = Self(
6989        1000028002i32,
6990    );
6991    pub const CU_MODULE_CREATE_INFO: Self = Self(1000029000i32);
6992    pub const CU_FUNCTION_CREATE_INFO: Self = Self(1000029001i32);
6993    pub const CU_LAUNCH_INFO: Self = Self(1000029002i32);
6994    pub const CU_MODULE_TEXTURING_MODE_CREATE_INFO: Self = Self(1000029004i32);
6995    pub const IMAGE_VIEW_HANDLE_INFO: Self = Self(1000030000i32);
6996    pub const IMAGE_VIEW_ADDRESS_PROPERTIES: Self = Self(1000030001i32);
6997    pub const VIDEO_ENCODE_H264_CAPABILITIES: Self = Self(1000038000i32);
6998    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
6999        1000038001i32,
7000    );
7001    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO: Self = Self(1000038002i32);
7002    pub const VIDEO_ENCODE_H264_PICTURE_INFO: Self = Self(1000038003i32);
7003    pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO: Self = Self(1000038004i32);
7004    pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO: Self = Self(1000038005i32);
7005    pub const VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO: Self = Self(1000038006i32);
7006    pub const VIDEO_ENCODE_H264_PROFILE_INFO: Self = Self(1000038007i32);
7007    pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO: Self = Self(1000038008i32);
7008    pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO: Self = Self(1000038009i32);
7009    pub const VIDEO_ENCODE_H264_SESSION_CREATE_INFO: Self = Self(1000038010i32);
7010    pub const VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES: Self = Self(1000038011i32);
7011    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO: Self = Self(1000038012i32);
7012    pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO: Self = Self(
7013        1000038013i32,
7014    );
7015    pub const VIDEO_ENCODE_H265_CAPABILITIES: Self = Self(1000039000i32);
7016    pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
7017        1000039001i32,
7018    );
7019    pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO: Self = Self(1000039002i32);
7020    pub const VIDEO_ENCODE_H265_PICTURE_INFO: Self = Self(1000039003i32);
7021    pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO: Self = Self(1000039004i32);
7022    pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO: Self = Self(1000039005i32);
7023    pub const VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO: Self = Self(1000039006i32);
7024    pub const VIDEO_ENCODE_H265_PROFILE_INFO: Self = Self(1000039007i32);
7025    pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO: Self = Self(1000039009i32);
7026    pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO: Self = Self(1000039010i32);
7027    pub const VIDEO_ENCODE_H265_SESSION_CREATE_INFO: Self = Self(1000039011i32);
7028    pub const VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES: Self = Self(1000039012i32);
7029    pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO: Self = Self(1000039013i32);
7030    pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO: Self = Self(
7031        1000039014i32,
7032    );
7033    pub const VIDEO_DECODE_H264_CAPABILITIES: Self = Self(1000040000i32);
7034    pub const VIDEO_DECODE_H264_PICTURE_INFO: Self = Self(1000040001i32);
7035    pub const VIDEO_DECODE_H264_PROFILE_INFO: Self = Self(1000040003i32);
7036    pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
7037        1000040004i32,
7038    );
7039    pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO: Self = Self(1000040005i32);
7040    pub const VIDEO_DECODE_H264_DPB_SLOT_INFO: Self = Self(1000040006i32);
7041    pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES: Self = Self(1000041000i32);
7042    pub const STREAM_DESCRIPTOR_SURFACE_CREATE_INFO: Self = Self(1000049000i32);
7043    pub const PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES: Self = Self(1000050000i32);
7044    pub const IMPORT_MEMORY_WIN32_HANDLE_INFO: Self = Self(1000057000i32);
7045    pub const EXPORT_MEMORY_WIN32_HANDLE_INFO: Self = Self(1000057001i32);
7046    pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO: Self = Self(1000058000i32);
7047    pub const VALIDATION_FLAGS: Self = Self(1000061000i32);
7048    pub const VI_SURFACE_CREATE_INFO: Self = Self(1000062000i32);
7049    pub const IMAGE_VIEW_ASTC_DECODE_MODE: Self = Self(1000067000i32);
7050    pub const PHYSICAL_DEVICE_ASTC_DECODE_FEATURES: Self = Self(1000067001i32);
7051    pub const MEMORY_WIN32_HANDLE_PROPERTIES: Self = Self(1000073002i32);
7052    pub const MEMORY_GET_WIN32_HANDLE_INFO: Self = Self(1000073003i32);
7053    pub const IMPORT_MEMORY_FD_INFO: Self = Self(1000074000i32);
7054    pub const MEMORY_FD_PROPERTIES: Self = Self(1000074001i32);
7055    pub const MEMORY_GET_FD_INFO: Self = Self(1000074002i32);
7056    pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO: Self = Self(1000078000i32);
7057    pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO: Self = Self(1000078001i32);
7058    pub const D3D12_FENCE_SUBMIT_INFO: Self = Self(1000078002i32);
7059    pub const SEMAPHORE_GET_WIN32_HANDLE_INFO: Self = Self(1000078003i32);
7060    pub const IMPORT_SEMAPHORE_FD_INFO: Self = Self(1000079000i32);
7061    pub const SEMAPHORE_GET_FD_INFO: Self = Self(1000079001i32);
7062    pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO: Self = Self(
7063        1000081000i32,
7064    );
7065    pub const PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES: Self = Self(1000081001i32);
7066    pub const CONDITIONAL_RENDERING_BEGIN_INFO: Self = Self(1000081002i32);
7067    pub const PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES: Self = Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
7068    pub const PRESENT_REGIONS: Self = Self(1000084000i32);
7069    pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO: Self = Self(1000087000i32);
7070    pub const SURFACE_CAPABILITIES_2: Self = Self(1000090000i32);
7071    pub const SURFACE_CAPABILITIES2: Self = Self::SURFACE_CAPABILITIES_2;
7072    pub const DISPLAY_POWER_INFO: Self = Self(1000091000i32);
7073    pub const DEVICE_EVENT_INFO: Self = Self(1000091001i32);
7074    pub const DISPLAY_EVENT_INFO: Self = Self(1000091002i32);
7075    pub const SWAPCHAIN_COUNTER_CREATE_INFO: Self = Self(1000091003i32);
7076    pub const PRESENT_TIMES_INFO: Self = Self(1000092000i32);
7077    pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES: Self = Self(
7078        1000097000i32,
7079    );
7080    pub const MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO: Self = Self(1000044009i32);
7081    pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO: Self = Self(1000098000i32);
7082    pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES: Self = Self(1000099000i32);
7083    pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO: Self = Self(1000099001i32);
7084    pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES: Self = Self(
7085        1000101000i32,
7086    );
7087    pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO: Self = Self(
7088        1000101001i32,
7089    );
7090    pub const PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES: Self = Self(1000102000i32);
7091    pub const PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO: Self = Self(
7092        1000102001i32,
7093    );
7094    pub const HDR_METADATA: Self = Self(1000105000i32);
7095    pub const PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES: Self = Self(
7096        1000110000i32,
7097    );
7098    pub const SHARED_PRESENT_SURFACE_CAPABILITIES: Self = Self(1000111000i32);
7099    pub const IMPORT_FENCE_WIN32_HANDLE_INFO: Self = Self(1000114000i32);
7100    pub const EXPORT_FENCE_WIN32_HANDLE_INFO: Self = Self(1000114001i32);
7101    pub const FENCE_GET_WIN32_HANDLE_INFO: Self = Self(1000114002i32);
7102    pub const IMPORT_FENCE_FD_INFO: Self = Self(1000115000i32);
7103    pub const FENCE_GET_FD_INFO: Self = Self(1000115001i32);
7104    pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES: Self = Self(1000116000i32);
7105    pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES: Self = Self(1000116001i32);
7106    pub const QUERY_POOL_PERFORMANCE_CREATE_INFO: Self = Self(1000116002i32);
7107    pub const PERFORMANCE_QUERY_SUBMIT_INFO: Self = Self(1000116003i32);
7108    pub const ACQUIRE_PROFILING_LOCK_INFO: Self = Self(1000116004i32);
7109    pub const PERFORMANCE_COUNTER: Self = Self(1000116005i32);
7110    pub const PERFORMANCE_COUNTER_DESCRIPTION: Self = Self(1000116006i32);
7111    pub const PERFORMANCE_QUERY_RESERVATION_INFO: Self = Self(1000116007i32);
7112    pub const PHYSICAL_DEVICE_SURFACE_INFO_2: Self = Self(1000119000i32);
7113    pub const SURFACE_FORMAT_2: Self = Self(1000119002i32);
7114    pub const DISPLAY_PROPERTIES_2: Self = Self(1000121000i32);
7115    pub const DISPLAY_PLANE_PROPERTIES_2: Self = Self(1000121001i32);
7116    pub const DISPLAY_MODE_PROPERTIES_2: Self = Self(1000121002i32);
7117    pub const DISPLAY_PLANE_INFO_2: Self = Self(1000121003i32);
7118    pub const DISPLAY_PLANE_CAPABILITIES_2: Self = Self(1000121004i32);
7119    pub const IOS_SURFACE_CREATE_INFO: Self = Self(1000122000i32);
7120    pub const MACOS_SURFACE_CREATE_INFO: Self = Self(1000123000i32);
7121    pub const DEBUG_UTILS_OBJECT_NAME_INFO: Self = Self(1000128000i32);
7122    pub const DEBUG_UTILS_OBJECT_TAG_INFO: Self = Self(1000128001i32);
7123    pub const DEBUG_UTILS_LABEL: Self = Self(1000128002i32);
7124    pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA: Self = Self(1000128003i32);
7125    pub const DEBUG_UTILS_MESSENGER_CREATE_INFO: Self = Self(1000128004i32);
7126    pub const ANDROID_HARDWARE_BUFFER_USAGE: Self = Self(1000129000i32);
7127    pub const ANDROID_HARDWARE_BUFFER_PROPERTIES: Self = Self(1000129001i32);
7128    pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES: Self = Self(1000129002i32);
7129    pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO: Self = Self(1000129003i32);
7130    pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO: Self = Self(1000129004i32);
7131    pub const EXTERNAL_FORMAT: Self = Self(1000129005i32);
7132    pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2: Self = Self(1000129006i32);
7133    pub const PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES: Self = Self(1000134000i32);
7134    pub const PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES: Self = Self(1000134001i32);
7135    pub const EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE: Self = Self(1000134002i32);
7136    pub const EXECUTION_GRAPH_PIPELINE_CREATE_INFO: Self = Self(1000134003i32);
7137    pub const PIPELINE_SHADER_STAGE_NODE_CREATE_INFO: Self = Self(1000134004i32);
7138    pub const TEXEL_BUFFER_DESCRIPTOR_INFO: Self = Self(1000135000i32);
7139    pub const IMAGE_DESCRIPTOR_INFO: Self = Self(1000135001i32);
7140    pub const RESOURCE_DESCRIPTOR_INFO: Self = Self(1000135002i32);
7141    pub const BIND_HEAP_INFO: Self = Self(1000135003i32);
7142    pub const PUSH_DATA_INFO: Self = Self(1000135004i32);
7143    pub const DESCRIPTOR_SET_AND_BINDING_MAPPING: Self = Self(1000135005i32);
7144    pub const SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO: Self = Self(1000135006i32);
7145    pub const OPAQUE_CAPTURE_DATA_CREATE_INFO: Self = Self(1000135007i32);
7146    pub const PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES: Self = Self(1000135008i32);
7147    pub const PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES: Self = Self(1000135009i32);
7148    pub const COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO: Self = Self(
7149        1000135010i32,
7150    );
7151    pub const SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO: Self = Self(1000135011i32);
7152    pub const INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN: Self = Self(1000135012i32);
7153    pub const SUBSAMPLED_IMAGE_FORMAT_PROPERTIES: Self = Self(1000135013i32);
7154    pub const PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES: Self = Self(
7155        1000135014i32,
7156    );
7157    pub const ATTACHMENT_SAMPLE_COUNT_INFO: Self = Self(1000044008i32);
7158    pub const PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES: Self = Self(1000141000i32);
7159    pub const SAMPLE_LOCATIONS_INFO: Self = Self(1000143000i32);
7160    pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO: Self = Self(1000143001i32);
7161    pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO: Self = Self(1000143002i32);
7162    pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES: Self = Self(1000143003i32);
7163    pub const MULTISAMPLE_PROPERTIES: Self = Self(1000143004i32);
7164    pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES: Self = Self(
7165        1000148000i32,
7166    );
7167    pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES: Self = Self(
7168        1000148001i32,
7169    );
7170    pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO: Self = Self(
7171        1000148002i32,
7172    );
7173    pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO: Self = Self(1000149000i32);
7174    pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE: Self = Self(1000150007i32);
7175    pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO: Self = Self(1000150000i32);
7176    pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO: Self = Self(1000150002i32);
7177    pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA: Self = Self(1000150003i32);
7178    pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA: Self = Self(1000150004i32);
7179    pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA: Self = Self(1000150005i32);
7180    pub const ACCELERATION_STRUCTURE_GEOMETRY: Self = Self(1000150006i32);
7181    pub const ACCELERATION_STRUCTURE_VERSION_INFO: Self = Self(1000150009i32);
7182    pub const COPY_ACCELERATION_STRUCTURE_INFO: Self = Self(1000150010i32);
7183    pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO: Self = Self(1000150011i32);
7184    pub const COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO: Self = Self(1000150012i32);
7185    pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES: Self = Self(
7186        1000150013i32,
7187    );
7188    pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES: Self = Self(
7189        1000150014i32,
7190    );
7191    pub const ACCELERATION_STRUCTURE_CREATE_INFO: Self = Self(1000150017i32);
7192    pub const ACCELERATION_STRUCTURE_BUILD_SIZES_INFO: Self = Self(1000150020i32);
7193    pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES: Self = Self(1000347000i32);
7194    pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES: Self = Self(
7195        1000347001i32,
7196    );
7197    pub const RAY_TRACING_PIPELINE_CREATE_INFO: Self = Self(1000150015i32);
7198    pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO: Self = Self(1000150016i32);
7199    pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO: Self = Self(1000150018i32);
7200    pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES: Self = Self(1000348013i32);
7201    pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO: Self = Self(1000152000i32);
7202    pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES: Self = Self(1000154000i32);
7203    pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES: Self = Self(1000154001i32);
7204    pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST: Self = Self(1000158000i32);
7205    pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO: Self = Self(1000158002i32);
7206    pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO: Self = Self(1000158003i32);
7207    pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO: Self = Self(1000158004i32);
7208    pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES: Self = Self(1000158005i32);
7209    pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2: Self = Self(1000158006i32);
7210    pub const VALIDATION_CACHE_CREATE_INFO: Self = Self(1000160000i32);
7211    pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO: Self = Self(1000160001i32);
7212    pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES: Self = Self(1000163000i32);
7213    pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES: Self = Self(1000163001i32);
7214    pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO: Self = Self(
7215        1000164000i32,
7216    );
7217    pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES: Self = Self(1000164001i32);
7218    pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES: Self = Self(1000164002i32);
7219    pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO: Self = Self(
7220        1000164005i32,
7221    );
7222    pub const GEOMETRY: Self = Self(1000165003i32);
7223    pub const GEOMETRY_TRIANGLES: Self = Self(1000165004i32);
7224    pub const GEOMETRY_AABB: Self = Self(1000165005i32);
7225    pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO: Self = Self(1000165006i32);
7226    pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO: Self = Self(
7227        1000165008i32,
7228    );
7229    pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES: Self = Self(1000165009i32);
7230    pub const ACCELERATION_STRUCTURE_INFO: Self = Self(1000165012i32);
7231    pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES: Self = Self(
7232        1000166000i32,
7233    );
7234    pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO: Self = Self(
7235        1000166001i32,
7236    );
7237    pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO: Self = Self(1000170000i32);
7238    pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES: Self = Self(
7239        1000170001i32,
7240    );
7241    pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES: Self = Self(
7242        1000172000i32,
7243    );
7244    pub const IMPORT_MEMORY_HOST_POINTER_INFO: Self = Self(1000178000i32);
7245    pub const MEMORY_HOST_POINTER_PROPERTIES: Self = Self(1000178001i32);
7246    pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES: Self = Self(
7247        1000178002i32,
7248    );
7249    pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES: Self = Self(1000181000i32);
7250    pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO: Self = Self(1000183000i32);
7251    pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES: Self = Self(1000185000i32);
7252    pub const VIDEO_DECODE_H265_CAPABILITIES: Self = Self(1000187000i32);
7253    pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
7254        1000187001i32,
7255    );
7256    pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO: Self = Self(1000187002i32);
7257    pub const VIDEO_DECODE_H265_PROFILE_INFO: Self = Self(1000187003i32);
7258    pub const VIDEO_DECODE_H265_PICTURE_INFO: Self = Self(1000187004i32);
7259    pub const VIDEO_DECODE_H265_DPB_SLOT_INFO: Self = Self(1000187005i32);
7260    pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO: Self = Self(1000189000i32);
7261    pub const PRESENT_FRAME_TOKEN: Self = Self(1000191000i32);
7262    pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES: Self = Self(1000202000i32);
7263    pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES: Self = Self(1000202001i32);
7264    pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES: Self = Self(
7265        1000204000i32,
7266    );
7267    pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO: Self = Self(
7268        1000205000i32,
7269    );
7270    pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES: Self = Self(1000205002i32);
7271    pub const CHECKPOINT_DATA: Self = Self(1000206000i32);
7272    pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES: Self = Self(1000206001i32);
7273    pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2: Self = Self(1000314008i32);
7274    pub const CHECKPOINT_DATA_2: Self = Self(1000314009i32);
7275    pub const PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES: Self = Self(1000208000i32);
7276    pub const SWAPCHAIN_TIMING_PROPERTIES: Self = Self(1000208001i32);
7277    pub const SWAPCHAIN_TIME_DOMAIN_PROPERTIES: Self = Self(1000208002i32);
7278    pub const PRESENT_TIMINGS_INFO: Self = Self(1000208003i32);
7279    pub const PRESENT_TIMING_INFO: Self = Self(1000208004i32);
7280    pub const PAST_PRESENTATION_TIMING_INFO: Self = Self(1000208005i32);
7281    pub const PAST_PRESENTATION_TIMING_PROPERTIES: Self = Self(1000208006i32);
7282    pub const PAST_PRESENTATION_TIMING: Self = Self(1000208007i32);
7283    pub const PRESENT_TIMING_SURFACE_CAPABILITIES: Self = Self(1000208008i32);
7284    pub const SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO: Self = Self(1000208009i32);
7285    pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES: Self = Self(
7286        1000209000i32,
7287    );
7288    pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO: Self = Self(1000210000i32);
7289    pub const INITIALIZE_PERFORMANCE_API_INFO: Self = Self(1000210001i32);
7290    pub const PERFORMANCE_MARKER_INFO: Self = Self(1000210002i32);
7291    pub const PERFORMANCE_STREAM_MARKER_INFO: Self = Self(1000210003i32);
7292    pub const PERFORMANCE_OVERRIDE_INFO: Self = Self(1000210004i32);
7293    pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO: Self = Self(1000210005i32);
7294    pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES: Self = Self(1000212000i32);
7295    pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES: Self = Self(1000213000i32);
7296    pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO: Self = Self(1000213001i32);
7297    pub const IMAGEPIPE_SURFACE_CREATE_INFO: Self = Self(1000214000i32);
7298    pub const METAL_SURFACE_CREATE_INFO: Self = Self(1000217000i32);
7299    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES: Self = Self(1000218000i32);
7300    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES: Self = Self(
7301        1000218001i32,
7302    );
7303    pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO: Self = Self(1000218002i32);
7304    pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO: Self = Self(1000044007i32);
7305    pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO: Self = Self(1000226000i32);
7306    pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO: Self = Self(
7307        1000226001i32,
7308    );
7309    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES: Self = Self(
7310        1000226002i32,
7311    );
7312    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES: Self = Self(1000226003i32);
7313    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE: Self = Self(1000226004i32);
7314    pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO: Self = Self(
7315        1000044006i32,
7316    );
7317    pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2: Self = Self(1000227000i32);
7318    pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES: Self = Self(1000229000i32);
7319    pub const PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES: Self = Self(1000231000i32);
7320    pub const PHYSICAL_DEVICE_SHADER_ABORT_FEATURES: Self = Self(1000233000i32);
7321    pub const DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO: Self = Self(1000233001i32);
7322    pub const PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES: Self = Self(1000233002i32);
7323    pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES: Self = Self(
7324        1000234000i32,
7325    );
7326    pub const PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES: Self = Self(1000235000i32);
7327    pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES: Self = Self(1000237000i32);
7328    pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES: Self = Self(1000238000i32);
7329    pub const MEMORY_PRIORITY_ALLOCATE_INFO: Self = Self(1000238001i32);
7330    pub const SURFACE_PROTECTED_CAPABILITIES: Self = Self(1000239000i32);
7331    pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES: Self = Self(
7332        1000240000i32,
7333    );
7334    pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES: Self = Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
7335    pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO: Self = Self(1000244002i32);
7336    pub const VALIDATION_FEATURES: Self = Self(1000247000i32);
7337    pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES: Self = Self(1000248000i32);
7338    pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES: Self = Self(1000249000i32);
7339    pub const COOPERATIVE_MATRIX_PROPERTIES: Self = Self(1000249001i32);
7340    pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES: Self = Self(1000249002i32);
7341    pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES: Self = Self(
7342        1000250000i32,
7343    );
7344    pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO: Self = Self(1000250001i32);
7345    pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION: Self = Self(1000250002i32);
7346    pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES: Self = Self(
7347        1000251000i32,
7348    );
7349    pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES: Self = Self(1000252000i32);
7350    pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES: Self = Self(1000254000i32);
7351    pub const PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO: Self = Self(
7352        1000254001i32,
7353    );
7354    pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES: Self = Self(1000254002i32);
7355    pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO: Self = Self(1000255000i32);
7356    pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE: Self = Self(1000255002i32);
7357    pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO: Self = Self(1000255001i32);
7358    pub const HEADLESS_SURFACE_CREATE_INFO: Self = Self(1000256000i32);
7359    pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES: Self = Self(1000260000i32);
7360    ///Not promoted to 1.3
7361    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES: Self = Self(
7362        1000267000i32,
7363    );
7364    pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES: Self = Self(
7365        1000269000i32,
7366    );
7367    pub const PIPELINE_INFO: Self = Self(1000269001i32);
7368    pub const PIPELINE_EXECUTABLE_PROPERTIES: Self = Self(1000269002i32);
7369    pub const PIPELINE_EXECUTABLE_INFO: Self = Self(1000269003i32);
7370    pub const PIPELINE_EXECUTABLE_STATISTIC: Self = Self(1000269004i32);
7371    pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION: Self = Self(1000269005i32);
7372    pub const PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES: Self = Self(1000272000i32);
7373    pub const PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES: Self = Self(1000272001i32);
7374    pub const MEMORY_MAP_PLACED_INFO: Self = Self(1000272002i32);
7375    pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES: Self = Self(1000273000i32);
7376    pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES: Self = Self(
7377        1000277000i32,
7378    );
7379    pub const GRAPHICS_SHADER_GROUP_CREATE_INFO: Self = Self(1000277001i32);
7380    pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO: Self = Self(1000277002i32);
7381    pub const INDIRECT_COMMANDS_LAYOUT_TOKEN: Self = Self(1000277003i32);
7382    pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO: Self = Self(1000277004i32);
7383    pub const GENERATED_COMMANDS_INFO: Self = Self(1000277005i32);
7384    pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO: Self = Self(1000277006i32);
7385    pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES: Self = Self(
7386        1000277007i32,
7387    );
7388    pub const PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES: Self = Self(
7389        1000278000i32,
7390    );
7391    pub const COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO: Self = Self(
7392        1000278001i32,
7393    );
7394    ///Not promoted to 1.3
7395    pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES: Self = Self(
7396        1000281000i32,
7397    );
7398    pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO: Self = Self(
7399        1000282000i32,
7400    );
7401    pub const RENDER_PASS_TRANSFORM_BEGIN_INFO: Self = Self(1000282001i32);
7402    pub const PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES: Self = Self(1000283000i32);
7403    pub const DEPTH_BIAS_INFO: Self = Self(1000283001i32);
7404    pub const DEPTH_BIAS_REPRESENTATION_INFO: Self = Self(1000283002i32);
7405    pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES: Self = Self(1000284000i32);
7406    pub const DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO: Self = Self(1000284001i32);
7407    pub const DEVICE_MEMORY_REPORT_CALLBACK_DATA: Self = Self(1000284002i32);
7408    pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO: Self = Self(1000287000i32);
7409    pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES: Self = Self(1000287001i32);
7410    pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES: Self = Self(1000287002i32);
7411    pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES: Self = Self(
7412        1000288000i32,
7413    );
7414    pub const PIPELINE_LIBRARY_CREATE_INFO: Self = Self(1000290000i32);
7415    pub const PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES: Self = Self(1000292000i32);
7416    pub const SURFACE_CAPABILITIES_PRESENT_BARRIER: Self = Self(1000292001i32);
7417    pub const SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO: Self = Self(1000292002i32);
7418    pub const PRESENT_ID: Self = Self(1000294000i32);
7419    pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES: Self = Self(1000294001i32);
7420    pub const VIDEO_ENCODE_INFO: Self = Self(1000299000i32);
7421    pub const VIDEO_ENCODE_RATE_CONTROL_INFO: Self = Self(1000299001i32);
7422    pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO: Self = Self(1000299002i32);
7423    pub const VIDEO_ENCODE_CAPABILITIES: Self = Self(1000299003i32);
7424    pub const VIDEO_ENCODE_USAGE_INFO: Self = Self(1000299004i32);
7425    pub const QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO: Self = Self(1000299005i32);
7426    pub const PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO: Self = Self(
7427        1000299006i32,
7428    );
7429    pub const VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES: Self = Self(1000299007i32);
7430    pub const VIDEO_ENCODE_QUALITY_LEVEL_INFO: Self = Self(1000299008i32);
7431    pub const VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO: Self = Self(1000299009i32);
7432    pub const VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO: Self = Self(1000299010i32);
7433    pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES: Self = Self(1000300000i32);
7434    pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO: Self = Self(1000300001i32);
7435    pub const CUDA_MODULE_CREATE_INFO: Self = Self(1000307000i32);
7436    pub const CUDA_FUNCTION_CREATE_INFO: Self = Self(1000307001i32);
7437    pub const CUDA_LAUNCH_INFO: Self = Self(1000307002i32);
7438    pub const PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES: Self = Self(1000307003i32);
7439    pub const PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES: Self = Self(1000307004i32);
7440    pub const PHYSICAL_DEVICE_TILE_SHADING_FEATURES: Self = Self(1000309000i32);
7441    pub const PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES: Self = Self(1000309001i32);
7442    pub const RENDER_PASS_TILE_SHADING_CREATE_INFO: Self = Self(1000309002i32);
7443    pub const PER_TILE_BEGIN_INFO: Self = Self(1000309003i32);
7444    pub const PER_TILE_END_INFO: Self = Self(1000309004i32);
7445    pub const DISPATCH_TILE_INFO: Self = Self(1000309005i32);
7446    pub const QUERY_LOW_LATENCY_SUPPORT: Self = Self(1000310000i32);
7447    pub const EXPORT_METAL_OBJECT_CREATE_INFO: Self = Self(1000311000i32);
7448    pub const EXPORT_METAL_OBJECTS_INFO: Self = Self(1000311001i32);
7449    pub const EXPORT_METAL_DEVICE_INFO: Self = Self(1000311002i32);
7450    pub const EXPORT_METAL_COMMAND_QUEUE_INFO: Self = Self(1000311003i32);
7451    pub const EXPORT_METAL_BUFFER_INFO: Self = Self(1000311004i32);
7452    pub const IMPORT_METAL_BUFFER_INFO: Self = Self(1000311005i32);
7453    pub const EXPORT_METAL_TEXTURE_INFO: Self = Self(1000311006i32);
7454    pub const IMPORT_METAL_TEXTURE_INFO: Self = Self(1000311007i32);
7455    pub const EXPORT_METAL_IO_SURFACE_INFO: Self = Self(1000311008i32);
7456    pub const IMPORT_METAL_IO_SURFACE_INFO: Self = Self(1000311009i32);
7457    pub const EXPORT_METAL_SHARED_EVENT_INFO: Self = Self(1000311010i32);
7458    pub const IMPORT_METAL_SHARED_EVENT_INFO: Self = Self(1000311011i32);
7459    pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES: Self = Self(1000316000i32);
7460    pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES: Self = Self(
7461        1000316001i32,
7462    );
7463    pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES: Self = Self(1000316002i32);
7464    pub const DESCRIPTOR_ADDRESS_INFO: Self = Self(1000316003i32);
7465    pub const DESCRIPTOR_GET_INFO: Self = Self(1000316004i32);
7466    pub const BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000316005i32);
7467    pub const IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000316006i32);
7468    pub const IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000316007i32);
7469    pub const SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000316008i32);
7470    pub const OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO: Self = Self(1000316010i32);
7471    pub const DESCRIPTOR_BUFFER_BINDING_INFO: Self = Self(1000316011i32);
7472    pub const DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE: Self = Self(
7473        1000316012i32,
7474    );
7475    pub const ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(
7476        1000316009i32,
7477    );
7478    pub const DEVICE_MEMORY_COPY: Self = Self(1000318000i32);
7479    pub const COPY_DEVICE_MEMORY_INFO: Self = Self(1000318001i32);
7480    pub const DEVICE_MEMORY_IMAGE_COPY: Self = Self(1000318002i32);
7481    pub const COPY_DEVICE_MEMORY_IMAGE_INFO: Self = Self(1000318003i32);
7482    pub const MEMORY_RANGE_BARRIERS_INFO: Self = Self(1000318004i32);
7483    pub const MEMORY_RANGE_BARRIER: Self = Self(1000318005i32);
7484    pub const PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES: Self = Self(
7485        1000318006i32,
7486    );
7487    pub const BIND_INDEX_BUFFER_3_INFO: Self = Self(1000318007i32);
7488    pub const BIND_VERTEX_BUFFER_3_INFO: Self = Self(1000318008i32);
7489    pub const DRAW_INDIRECT_2_INFO: Self = Self(1000318009i32);
7490    pub const DRAW_INDIRECT_COUNT_2_INFO: Self = Self(1000318010i32);
7491    pub const DISPATCH_INDIRECT_2_INFO: Self = Self(1000318011i32);
7492    pub const CONDITIONAL_RENDERING_BEGIN_INFO_2: Self = Self(1000318012i32);
7493    pub const BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO: Self = Self(1000318013i32);
7494    pub const MEMORY_MARKER_INFO: Self = Self(1000318014i32);
7495    pub const ACCELERATION_STRUCTURE_CREATE_INFO_2: Self = Self(1000318015i32);
7496    pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES: Self = Self(
7497        1000320000i32,
7498    );
7499    pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES: Self = Self(
7500        1000320001i32,
7501    );
7502    pub const GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO: Self = Self(1000320002i32);
7503    pub const PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES: Self = Self(
7504        1000321000i32,
7505    );
7506    pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES: Self = Self(
7507        1000322000i32,
7508    );
7509    pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES: Self = Self(
7510        1000323000i32,
7511    );
7512    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES: Self = Self(
7513        1000326000i32,
7514    );
7515    pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES: Self = Self(
7516        1000326001i32,
7517    );
7518    pub const PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO: Self = Self(
7519        1000326002i32,
7520    );
7521    pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA: Self = Self(
7522        1000327000i32,
7523    );
7524    pub const PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES: Self = Self(
7525        1000327001i32,
7526    );
7527    pub const ACCELERATION_STRUCTURE_MOTION_INFO: Self = Self(1000327002i32);
7528    pub const PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES: Self = Self(
7529        1000330000i32,
7530    );
7531    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES: Self = Self(
7532        1000332000i32,
7533    );
7534    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES: Self = Self(
7535        1000332001i32,
7536    );
7537    pub const COPY_COMMAND_TRANSFORM_INFO: Self = Self(1000333000i32);
7538    pub const PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES: Self = Self(
7539        1000336000i32,
7540    );
7541    pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES: Self = Self(
7542        1000338000i32,
7543    );
7544    pub const IMAGE_COMPRESSION_CONTROL: Self = Self(1000338001i32);
7545    pub const IMAGE_COMPRESSION_PROPERTIES: Self = Self(1000338004i32);
7546    pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES: Self = Self(
7547        1000339000i32,
7548    );
7549    pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES: Self = Self(1000340000i32);
7550    pub const PHYSICAL_DEVICE_FAULT_FEATURES: Self = Self(1000341000i32);
7551    pub const DEVICE_FAULT_COUNTS: Self = Self(1000341001i32);
7552    pub const DEVICE_FAULT_INFO: Self = Self(1000341002i32);
7553    pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES: Self = Self(1000344000i32);
7554    pub const DIRECTFB_SURFACE_CREATE_INFO: Self = Self(1000346000i32);
7555    pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES: Self = Self(
7556        1000352000i32,
7557    );
7558    pub const VERTEX_INPUT_BINDING_DESCRIPTION_2: Self = Self(1000352001i32);
7559    pub const VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2: Self = Self(1000352002i32);
7560    pub const PHYSICAL_DEVICE_DRM_PROPERTIES: Self = Self(1000353000i32);
7561    pub const PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES: Self = Self(
7562        1000354000i32,
7563    );
7564    pub const DEVICE_ADDRESS_BINDING_CALLBACK_DATA: Self = Self(1000354001i32);
7565    pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES: Self = Self(1000355000i32);
7566    pub const PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO: Self = Self(
7567        1000355001i32,
7568    );
7569    pub const PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES: Self = Self(
7570        1000356000i32,
7571    );
7572    pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO: Self = Self(1000364000i32);
7573    pub const MEMORY_ZIRCON_HANDLE_PROPERTIES: Self = Self(1000364001i32);
7574    pub const MEMORY_GET_ZIRCON_HANDLE_INFO: Self = Self(1000364002i32);
7575    pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO: Self = Self(1000365000i32);
7576    pub const SEMAPHORE_GET_ZIRCON_HANDLE_INFO: Self = Self(1000365001i32);
7577    pub const BUFFER_COLLECTION_CREATE_INFO: Self = Self(1000366000i32);
7578    pub const IMPORT_MEMORY_BUFFER_COLLECTION: Self = Self(1000366001i32);
7579    pub const BUFFER_COLLECTION_IMAGE_CREATE_INFO: Self = Self(1000366002i32);
7580    pub const BUFFER_COLLECTION_PROPERTIES: Self = Self(1000366003i32);
7581    pub const BUFFER_CONSTRAINTS_INFO: Self = Self(1000366004i32);
7582    pub const BUFFER_COLLECTION_BUFFER_CREATE_INFO: Self = Self(1000366005i32);
7583    pub const IMAGE_CONSTRAINTS_INFO: Self = Self(1000366006i32);
7584    pub const IMAGE_FORMAT_CONSTRAINTS_INFO: Self = Self(1000366007i32);
7585    pub const SYSMEM_COLOR_SPACE: Self = Self(1000366008i32);
7586    pub const BUFFER_COLLECTION_CONSTRAINTS_INFO: Self = Self(1000366009i32);
7587    pub const SUBPASS_SHADING_PIPELINE_CREATE_INFO: Self = Self(1000369000i32);
7588    pub const PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES: Self = Self(1000369001i32);
7589    pub const PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES: Self = Self(1000369002i32);
7590    pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES: Self = Self(1000370000i32);
7591    pub const MEMORY_GET_REMOTE_ADDRESS_INFO: Self = Self(1000371000i32);
7592    pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES: Self = Self(1000371001i32);
7593    pub const PIPELINE_PROPERTIES_IDENTIFIER: Self = Self(1000372000i32);
7594    pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES: Self = Self(1000372001i32);
7595    pub const PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES: Self = Self(1000375000i32);
7596    pub const FRAME_BOUNDARY: Self = Self(1000375001i32);
7597    pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES: Self = Self(
7598        1000376000i32,
7599    );
7600    pub const SUBPASS_RESOLVE_PERFORMANCE_QUERY: Self = Self(1000376001i32);
7601    pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO: Self = Self(1000376002i32);
7602    ///Not promoted to 1.3
7603    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES: Self = Self(
7604        1000377000i32,
7605    );
7606    pub const SCREEN_SURFACE_CREATE_INFO: Self = Self(1000378000i32);
7607    pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES: Self = Self(1000381000i32);
7608    pub const PIPELINE_COLOR_WRITE_CREATE_INFO: Self = Self(1000381001i32);
7609    pub const PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES: Self = Self(
7610        1000382000i32,
7611    );
7612    pub const PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES: Self = Self(
7613        1000386000i32,
7614    );
7615    pub const PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES: Self = Self(
7616        1000387000i32,
7617    );
7618    pub const PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES: Self = Self(
7619        1000390000i32,
7620    );
7621    pub const VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES: Self = Self(1000390001i32);
7622    pub const VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO: Self = Self(1000390002i32);
7623    pub const VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO: Self = Self(
7624        1000390003i32,
7625    );
7626    pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES: Self = Self(1000391000i32);
7627    pub const IMAGE_VIEW_MIN_LOD_CREATE_INFO: Self = Self(1000391001i32);
7628    pub const PHYSICAL_DEVICE_MULTI_DRAW_FEATURES: Self = Self(1000392000i32);
7629    pub const PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES: Self = Self(1000392001i32);
7630    pub const PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES: Self = Self(1000393000i32);
7631    pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES: Self = Self(1000395000i32);
7632    pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES: Self = Self(1000395001i32);
7633    pub const MICROMAP_BUILD_INFO: Self = Self(1000396000i32);
7634    pub const MICROMAP_VERSION_INFO: Self = Self(1000396001i32);
7635    pub const COPY_MICROMAP_INFO: Self = Self(1000396002i32);
7636    pub const COPY_MICROMAP_TO_MEMORY_INFO: Self = Self(1000396003i32);
7637    pub const COPY_MEMORY_TO_MICROMAP_INFO: Self = Self(1000396004i32);
7638    pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES: Self = Self(1000396005i32);
7639    pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES: Self = Self(1000396006i32);
7640    pub const MICROMAP_CREATE_INFO: Self = Self(1000396007i32);
7641    pub const MICROMAP_BUILD_SIZES_INFO: Self = Self(1000396008i32);
7642    pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP: Self = Self(
7643        1000396009i32,
7644    );
7645    pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES: Self = Self(1000397000i32);
7646    pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES: Self = Self(
7647        1000397001i32,
7648    );
7649    pub const ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP: Self = Self(
7650        1000397002i32,
7651    );
7652    pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES: Self = Self(
7653        1000404000i32,
7654    );
7655    pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES: Self = Self(
7656        1000404001i32,
7657    );
7658    pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES: Self = Self(
7659        1000404002i32,
7660    );
7661    pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES: Self = Self(1000411000i32);
7662    pub const SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO: Self = Self(
7663        1000411001i32,
7664    );
7665    pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES: Self = Self(
7666        1000412000i32,
7667    );
7668    pub const DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO: Self = Self(1000417000i32);
7669    pub const PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES: Self = Self(1000417001i32);
7670    pub const PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES: Self = Self(1000417002i32);
7671    pub const PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES: Self = Self(
7672        1000418000i32,
7673    );
7674    pub const IMAGE_VIEW_SLICED_CREATE_INFO: Self = Self(1000418001i32);
7675    pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES: Self = Self(
7676        1000420000i32,
7677    );
7678    pub const DESCRIPTOR_SET_BINDING_REFERENCE: Self = Self(1000420001i32);
7679    pub const DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO: Self = Self(1000420002i32);
7680    pub const PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES: Self = Self(1000422000i32);
7681    pub const PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES: Self = Self(1000424000i32);
7682    pub const PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES: Self = Self(1000424001i32);
7683    pub const RENDER_PASS_STRIPE_BEGIN_INFO: Self = Self(1000424002i32);
7684    pub const RENDER_PASS_STRIPE_INFO: Self = Self(1000424003i32);
7685    pub const RENDER_PASS_STRIPE_SUBMIT_INFO: Self = Self(1000424004i32);
7686    pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO: Self = Self::RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO;
7687    pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES: Self = Self(1000426000i32);
7688    pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES: Self = Self(
7689        1000428000i32,
7690    );
7691    pub const COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO: Self = Self(1000428001i32);
7692    pub const PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO: Self = Self(1000428002i32);
7693    pub const PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES: Self = Self(
7694        1000429008i32,
7695    );
7696    pub const ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA: Self = Self(
7697        1000429009i32,
7698    );
7699    pub const ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA: Self = Self(1000429010i32);
7700    pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES: Self = Self(
7701        1000430000i32,
7702    );
7703    pub const PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES: Self = Self(
7704        1000434000i32,
7705    );
7706    pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES: Self = Self(
7707        1000437000i32,
7708    );
7709    pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES: Self = Self(1000440000i32);
7710    pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES: Self = Self(1000440001i32);
7711    pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO: Self = Self(1000440002i32);
7712    pub const PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES: Self = Self(1000451000i32);
7713    pub const PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES: Self = Self(
7714        1000451001i32,
7715    );
7716    pub const NATIVE_BUFFER_USAGE: Self = Self(1000452000i32);
7717    pub const NATIVE_BUFFER_PROPERTIES: Self = Self(1000452001i32);
7718    pub const NATIVE_BUFFER_FORMAT_PROPERTIES: Self = Self(1000452002i32);
7719    pub const IMPORT_NATIVE_BUFFER_INFO: Self = Self(1000452003i32);
7720    pub const MEMORY_GET_NATIVE_BUFFER_INFO: Self = Self(1000452004i32);
7721    pub const EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED: Self = Self(1000453000i32);
7722    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES: Self = Self(
7723        1000455000i32,
7724    );
7725    pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES: Self = Self(
7726        1000455001i32,
7727    );
7728    pub const PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES: Self = Self(
7729        1000458000i32,
7730    );
7731    pub const RENDER_PASS_CREATION_CONTROL: Self = Self(1000458001i32);
7732    pub const RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO: Self = Self(1000458002i32);
7733    pub const RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO: Self = Self(1000458003i32);
7734    pub const DIRECT_DRIVER_LOADING_INFO: Self = Self(1000459000i32);
7735    pub const DIRECT_DRIVER_LOADING_LIST: Self = Self(1000459001i32);
7736    pub const TENSOR_CREATE_INFO: Self = Self(1000460000i32);
7737    pub const TENSOR_VIEW_CREATE_INFO: Self = Self(1000460001i32);
7738    pub const BIND_TENSOR_MEMORY_INFO: Self = Self(1000460002i32);
7739    pub const WRITE_DESCRIPTOR_SET_TENSOR: Self = Self(1000460003i32);
7740    pub const PHYSICAL_DEVICE_TENSOR_PROPERTIES: Self = Self(1000460004i32);
7741    pub const TENSOR_FORMAT_PROPERTIES: Self = Self(1000460005i32);
7742    pub const TENSOR_DESCRIPTION: Self = Self(1000460006i32);
7743    pub const TENSOR_MEMORY_REQUIREMENTS_INFO: Self = Self(1000460007i32);
7744    pub const TENSOR_MEMORY_BARRIER: Self = Self(1000460008i32);
7745    pub const PHYSICAL_DEVICE_TENSOR_FEATURES: Self = Self(1000460009i32);
7746    pub const DEVICE_TENSOR_MEMORY_REQUIREMENTS: Self = Self(1000460010i32);
7747    pub const COPY_TENSOR_INFO: Self = Self(1000460011i32);
7748    pub const TENSOR_COPY: Self = Self(1000460012i32);
7749    pub const TENSOR_DEPENDENCY_INFO: Self = Self(1000460013i32);
7750    pub const MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR: Self = Self(1000460014i32);
7751    pub const PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO: Self = Self(1000460015i32);
7752    pub const EXTERNAL_TENSOR_PROPERTIES: Self = Self(1000460016i32);
7753    pub const EXTERNAL_MEMORY_TENSOR_CREATE_INFO: Self = Self(1000460017i32);
7754    pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES: Self = Self(
7755        1000460018i32,
7756    );
7757    pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES: Self = Self(
7758        1000460019i32,
7759    );
7760    pub const DESCRIPTOR_GET_TENSOR_INFO: Self = Self(1000460020i32);
7761    pub const TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000460021i32);
7762    pub const TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO: Self = Self(1000460022i32);
7763    pub const FRAME_BOUNDARY_TENSORS: Self = Self(1000460023i32);
7764    pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES: Self = Self(
7765        1000462000i32,
7766    );
7767    pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES: Self = Self(
7768        1000462001i32,
7769    );
7770    pub const PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO: Self = Self(
7771        1000462002i32,
7772    );
7773    pub const SHADER_MODULE_IDENTIFIER: Self = Self(1000462003i32);
7774    pub const PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES: Self = Self(1000464000i32);
7775    pub const PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES: Self = Self(1000464001i32);
7776    pub const OPTICAL_FLOW_IMAGE_FORMAT_INFO: Self = Self(1000464002i32);
7777    pub const OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES: Self = Self(1000464003i32);
7778    pub const OPTICAL_FLOW_SESSION_CREATE_INFO: Self = Self(1000464004i32);
7779    pub const OPTICAL_FLOW_EXECUTE_INFO: Self = Self(1000464005i32);
7780    pub const OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO: Self = Self(1000464010i32);
7781    pub const PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES: Self = Self(1000465000i32);
7782    pub const PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES: Self = Self(
7783        1000468000i32,
7784    );
7785    pub const PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES: Self = Self(
7786        1000468001i32,
7787    );
7788    pub const ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES: Self = Self(
7789        1000468002i32,
7790    );
7791    pub const PHYSICAL_DEVICE_ANTI_LAG_FEATURES: Self = Self(1000476000i32);
7792    pub const ANTI_LAG_DATA: Self = Self(1000476001i32);
7793    pub const ANTI_LAG_PRESENTATION_INFO: Self = Self(1000476002i32);
7794    pub const PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES: Self = Self(1000478000i32);
7795    pub const ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA: Self = Self(
7796        1000478001i32,
7797    );
7798    pub const SURFACE_CAPABILITIES_PRESENT_ID_2: Self = Self(1000479000i32);
7799    pub const PRESENT_ID_2: Self = Self(1000479001i32);
7800    pub const PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES: Self = Self(1000479002i32);
7801    pub const SURFACE_CAPABILITIES_PRESENT_WAIT_2: Self = Self(1000480000i32);
7802    pub const PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES: Self = Self(1000480001i32);
7803    pub const PRESENT_WAIT_2_INFO: Self = Self(1000480002i32);
7804    pub const PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES: Self = Self(
7805        1000481000i32,
7806    );
7807    pub const PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES: Self = Self(1000482000i32);
7808    pub const PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES: Self = Self(1000482001i32);
7809    pub const SHADER_CREATE_INFO: Self = Self(1000482002i32);
7810    pub const SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: Self = Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
7811    pub const PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES: Self = Self(1000483000i32);
7812    pub const PIPELINE_BINARY_CREATE_INFO: Self = Self(1000483001i32);
7813    pub const PIPELINE_BINARY_INFO: Self = Self(1000483002i32);
7814    pub const PIPELINE_BINARY_KEY: Self = Self(1000483003i32);
7815    pub const PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES: Self = Self(1000483004i32);
7816    pub const RELEASE_CAPTURED_PIPELINE_DATA_INFO: Self = Self(1000483005i32);
7817    pub const PIPELINE_BINARY_DATA_INFO: Self = Self(1000483006i32);
7818    pub const PIPELINE_CREATE_INFO: Self = Self(1000483007i32);
7819    pub const DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL: Self = Self(1000483008i32);
7820    pub const PIPELINE_BINARY_HANDLES_INFO: Self = Self(1000483009i32);
7821    pub const PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES: Self = Self(1000484000i32);
7822    pub const TILE_PROPERTIES: Self = Self(1000484001i32);
7823    pub const PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES: Self = Self(1000485000i32);
7824    pub const AMIGO_PROFILING_SUBMIT_INFO: Self = Self(1000485001i32);
7825    pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES: Self = Self(
7826        1000488000i32,
7827    );
7828    pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES: Self = Self(
7829        1000490000i32,
7830    );
7831    pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES: Self = Self(
7832        1000490001i32,
7833    );
7834    pub const PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES: Self = Self(1000491000i32);
7835    pub const PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES: Self = Self(1000491001i32);
7836    pub const COOPERATIVE_VECTOR_PROPERTIES: Self = Self(1000491002i32);
7837    pub const CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO: Self = Self(1000491004i32);
7838    pub const PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES: Self = Self(
7839        1000492000i32,
7840    );
7841    pub const PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES: Self = Self(
7842        1000492001i32,
7843    );
7844    pub const PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES: Self = Self(
7845        1000495000i32,
7846    );
7847    pub const PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES: Self = Self(
7848        1000495001i32,
7849    );
7850    pub const LAYER_SETTINGS_CREATE_INFO: Self = Self(1000496000i32);
7851    pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES: Self = Self(1000497000i32);
7852    pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES: Self = Self(
7853        1000497001i32,
7854    );
7855    pub const PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES: Self = Self(
7856        1000498000i32,
7857    );
7858    pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES: Self = Self(
7859        1000499000i32,
7860    );
7861    pub const PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES: Self = Self(
7862        1000504000i32,
7863    );
7864    pub const LATENCY_SLEEP_MODE_INFO: Self = Self(1000505000i32);
7865    pub const LATENCY_SLEEP_INFO: Self = Self(1000505001i32);
7866    pub const SET_LATENCY_MARKER_INFO: Self = Self(1000505002i32);
7867    pub const GET_LATENCY_MARKER_INFO: Self = Self(1000505003i32);
7868    pub const LATENCY_TIMINGS_FRAME_REPORT: Self = Self(1000505004i32);
7869    pub const LATENCY_SUBMISSION_PRESENT_ID: Self = Self(1000505005i32);
7870    pub const OUT_OF_BAND_QUEUE_TYPE_INFO: Self = Self(1000505006i32);
7871    pub const SWAPCHAIN_LATENCY_CREATE_INFO: Self = Self(1000505007i32);
7872    pub const LATENCY_SURFACE_CAPABILITIES: Self = Self(1000505008i32);
7873    pub const DATA_GRAPH_PIPELINE_CREATE_INFO: Self = Self(1000507000i32);
7874    pub const DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO: Self = Self(1000507001i32);
7875    pub const DATA_GRAPH_PIPELINE_RESOURCE_INFO: Self = Self(1000507002i32);
7876    pub const DATA_GRAPH_PIPELINE_CONSTANT: Self = Self(1000507003i32);
7877    pub const DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO: Self = Self(
7878        1000507004i32,
7879    );
7880    pub const BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO: Self = Self(1000507005i32);
7881    pub const PHYSICAL_DEVICE_DATA_GRAPH_FEATURES: Self = Self(1000507006i32);
7882    pub const DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO: Self = Self(1000507007i32);
7883    pub const DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT: Self = Self(1000507008i32);
7884    pub const DATA_GRAPH_PIPELINE_INFO: Self = Self(1000507009i32);
7885    pub const DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO: Self = Self(
7886        1000507010i32,
7887    );
7888    pub const DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO: Self = Self(
7889        1000507011i32,
7890    );
7891    pub const DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT: Self = Self(
7892        1000507012i32,
7893    );
7894    pub const DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO: Self = Self(1000507013i32);
7895    pub const DATA_GRAPH_PIPELINE_DISPATCH_INFO: Self = Self(1000507014i32);
7896    pub const DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO: Self = Self(1000507016i32);
7897    pub const QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES: Self = Self(
7898        1000507017i32,
7899    );
7900    pub const QUEUE_FAMILY_DATA_GRAPH_PROPERTIES: Self = Self(1000507018i32);
7901    pub const PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO: Self = Self(
7902        1000507019i32,
7903    );
7904    pub const DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO: Self = Self(
7905        1000507015i32,
7906    );
7907    pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES: Self = Self(
7908        1000510000i32,
7909    );
7910    pub const MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO: Self = Self(
7911        1000510001i32,
7912    );
7913    pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES: Self = Self(
7914        1000511000i32,
7915    );
7916    pub const VIDEO_DECODE_AV1_CAPABILITIES: Self = Self(1000512000i32);
7917    pub const VIDEO_DECODE_AV1_PICTURE_INFO: Self = Self(1000512001i32);
7918    pub const VIDEO_DECODE_AV1_PROFILE_INFO: Self = Self(1000512003i32);
7919    pub const VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
7920        1000512004i32,
7921    );
7922    pub const VIDEO_DECODE_AV1_DPB_SLOT_INFO: Self = Self(1000512005i32);
7923    pub const VIDEO_ENCODE_AV1_CAPABILITIES: Self = Self(1000513000i32);
7924    pub const VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
7925        1000513001i32,
7926    );
7927    pub const VIDEO_ENCODE_AV1_PICTURE_INFO: Self = Self(1000513002i32);
7928    pub const VIDEO_ENCODE_AV1_DPB_SLOT_INFO: Self = Self(1000513003i32);
7929    pub const PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES: Self = Self(1000513004i32);
7930    pub const VIDEO_ENCODE_AV1_PROFILE_INFO: Self = Self(1000513005i32);
7931    pub const VIDEO_ENCODE_AV1_RATE_CONTROL_INFO: Self = Self(1000513006i32);
7932    pub const VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO: Self = Self(1000513007i32);
7933    pub const VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES: Self = Self(1000513008i32);
7934    pub const VIDEO_ENCODE_AV1_SESSION_CREATE_INFO: Self = Self(1000513009i32);
7935    pub const VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO: Self = Self(1000513010i32);
7936    pub const PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES: Self = Self(1000514000i32);
7937    pub const VIDEO_DECODE_VP9_CAPABILITIES: Self = Self(1000514001i32);
7938    pub const VIDEO_DECODE_VP9_PICTURE_INFO: Self = Self(1000514002i32);
7939    pub const VIDEO_DECODE_VP9_PROFILE_INFO: Self = Self(1000514003i32);
7940    pub const PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES: Self = Self(1000515000i32);
7941    pub const VIDEO_INLINE_QUERY_INFO: Self = Self(1000515001i32);
7942    pub const PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES: Self = Self(
7943        1000516000i32,
7944    );
7945    pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES: Self = Self(1000518000i32);
7946    pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES: Self = Self(1000518001i32);
7947    pub const SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO: Self = Self(1000518002i32);
7948    pub const SAMPLER_CUBIC_WEIGHTS_CREATE_INFO: Self = Self(1000519000i32);
7949    pub const PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES: Self = Self(1000519001i32);
7950    pub const BLIT_IMAGE_CUBIC_WEIGHTS_INFO: Self = Self(1000519002i32);
7951    pub const PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES: Self = Self(1000520000i32);
7952    pub const SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO: Self = Self(
7953        1000520001i32,
7954    );
7955    pub const PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES: Self = Self(1000521000i32);
7956    pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES: Self = Self(
7957        1000524000i32,
7958    );
7959    pub const PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES: Self = Self(1000527000i32);
7960    pub const ATTACHMENT_FEEDBACK_LOOP_INFO: Self = Self(1000527001i32);
7961    pub const SCREEN_BUFFER_PROPERTIES: Self = Self(1000529000i32);
7962    pub const SCREEN_BUFFER_FORMAT_PROPERTIES: Self = Self(1000529001i32);
7963    pub const IMPORT_SCREEN_BUFFER_INFO: Self = Self(1000529002i32);
7964    pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES: Self = Self(
7965        1000529004i32,
7966    );
7967    pub const PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES: Self = Self(1000530000i32);
7968    pub const SET_DESCRIPTOR_BUFFER_OFFSETS_INFO: Self = Self(1000545007i32);
7969    pub const BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO: Self = Self(1000545008i32);
7970    pub const PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES: Self = Self(
7971        1000546000i32,
7972    );
7973    pub const PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES: Self = Self(1000547000i32);
7974    pub const PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES: Self = Self(1000547001i32);
7975    pub const TILE_MEMORY_REQUIREMENTS: Self = Self(1000547002i32);
7976    pub const TILE_MEMORY_BIND_INFO: Self = Self(1000547003i32);
7977    pub const TILE_MEMORY_SIZE_INFO: Self = Self(1000547004i32);
7978    pub const COPY_MEMORY_INDIRECT_INFO: Self = Self(1000549002i32);
7979    pub const COPY_MEMORY_TO_IMAGE_INDIRECT_INFO: Self = Self(1000549003i32);
7980    pub const DECOMPRESS_MEMORY_INFO: Self = Self(1000550002i32);
7981    pub const DISPLAY_SURFACE_STEREO_CREATE_INFO: Self = Self(1000551000i32);
7982    pub const DISPLAY_MODE_STEREO_PROPERTIES: Self = Self(1000551001i32);
7983    pub const VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES: Self = Self(1000552000i32);
7984    pub const VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO: Self = Self(1000552001i32);
7985    pub const VIDEO_ENCODE_INTRA_REFRESH_INFO: Self = Self(1000552002i32);
7986    pub const VIDEO_REFERENCE_INTRA_REFRESH_INFO: Self = Self(1000552003i32);
7987    pub const PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES: Self = Self(
7988        1000552004i32,
7989    );
7990    pub const VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES: Self = Self(1000553000i32);
7991    pub const VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES: Self = Self(1000553001i32);
7992    pub const VIDEO_ENCODE_QUANTIZATION_MAP_INFO: Self = Self(1000553002i32);
7993    pub const VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO: Self = Self(
7994        1000553005i32,
7995    );
7996    pub const PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES: Self = Self(
7997        1000553009i32,
7998    );
7999    pub const VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES: Self = Self(
8000        1000553003i32,
8001    );
8002    pub const VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES: Self = Self(
8003        1000553004i32,
8004    );
8005    pub const VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES: Self = Self(1000553006i32);
8006    pub const VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES: Self = Self(1000553007i32);
8007    pub const VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES: Self = Self(1000553008i32);
8008    pub const PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES: Self = Self(1000555000i32);
8009    pub const EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO: Self = Self(1000556000i32);
8010    pub const EXTERNAL_COMPUTE_QUEUE_CREATE_INFO: Self = Self(1000556001i32);
8011    pub const EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS: Self = Self(1000556002i32);
8012    pub const PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES: Self = Self(
8013        1000556003i32,
8014    );
8015    pub const PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES: Self = Self(
8016        1000558000i32,
8017    );
8018    pub const PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES: Self = Self(
8019        1000559000i32,
8020    );
8021    pub const PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES: Self = Self(1000562000i32);
8022    pub const PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES: Self = Self(1000562001i32);
8023    pub const PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST: Self = Self(1000562002i32);
8024    pub const PHYSICAL_DEVICE_LAYERED_API_PROPERTIES: Self = Self(1000562003i32);
8025    pub const PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES: Self = Self(1000562004i32);
8026    pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES: Self = Self(
8027        1000563000i32,
8028    );
8029    pub const PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES: Self = Self(
8030        1000564000i32,
8031    );
8032    pub const PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES: Self = Self(1000567000i32);
8033    pub const PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES: Self = Self(
8034        1000568000i32,
8035    );
8036    pub const PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES: Self = Self(
8037        1000569000i32,
8038    );
8039    pub const PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES: Self = Self(
8040        1000569001i32,
8041    );
8042    pub const CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT: Self = Self(
8043        1000569002i32,
8044    );
8045    pub const CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT: Self = Self(
8046        1000569003i32,
8047    );
8048    pub const CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT: Self = Self(
8049        1000569004i32,
8050    );
8051    pub const CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO: Self = Self(1000569005i32);
8052    pub const CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO: Self = Self(1000569006i32);
8053    pub const RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO: Self = Self(
8054        1000569007i32,
8055    );
8056    pub const PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES: Self = Self(
8057        1000570000i32,
8058    );
8059    pub const PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES: Self = Self(
8060        1000570001i32,
8061    );
8062    pub const WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE: Self = Self(
8063        1000570002i32,
8064    );
8065    pub const PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT: Self = Self(
8066        1000570003i32,
8067    );
8068    pub const BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO: Self = Self(1000570004i32);
8069    pub const PARTITIONED_ACCELERATION_STRUCTURE_FLAGS: Self = Self(1000570005i32);
8070    pub const INDIRECT_EXECUTION_SET_CREATE_INFO: Self = Self(1000572003i32);
8071    pub const WRITE_INDIRECT_EXECUTION_SET_PIPELINE: Self = Self(1000572008i32);
8072    pub const WRITE_INDIRECT_EXECUTION_SET_SHADER: Self = Self(1000572009i32);
8073    pub const INDIRECT_EXECUTION_SET_PIPELINE_INFO: Self = Self(1000572010i32);
8074    pub const INDIRECT_EXECUTION_SET_SHADER_INFO: Self = Self(1000572011i32);
8075    pub const INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO: Self = Self(1000572012i32);
8076    pub const GENERATED_COMMANDS_PIPELINE_INFO: Self = Self(1000572013i32);
8077    pub const GENERATED_COMMANDS_SHADER_INFO: Self = Self(1000572014i32);
8078    pub const PHYSICAL_DEVICE_FAULT_PROPERTIES: Self = Self(1000573001i32);
8079    pub const DEVICE_FAULT_DEBUG_INFO: Self = Self(1000573003i32);
8080    pub const PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES: Self = Self(1000574000i32);
8081    pub const MEMORY_BARRIER_ACCESS_FLAGS_3: Self = Self(1000574002i32);
8082    pub const PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES: Self = Self(
8083        1000575000i32,
8084    );
8085    pub const PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES: Self = Self(
8086        1000575001i32,
8087    );
8088    pub const IMAGE_ALIGNMENT_CONTROL_CREATE_INFO: Self = Self(1000575002i32);
8089    pub const PHYSICAL_DEVICE_SHADER_FMA_FEATURES: Self = Self(1000579000i32);
8090    pub const PUSH_CONSTANT_BANK_INFO: Self = Self(1000580000i32);
8091    pub const PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES: Self = Self(1000580001i32);
8092    pub const PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES: Self = Self(1000580002i32);
8093    pub const PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES: Self = Self(1000582000i32);
8094    pub const PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO: Self = Self(
8095        1000582001i32,
8096    );
8097    pub const PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES: Self = Self(1000584000i32);
8098    pub const PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES: Self = Self(1000584001i32);
8099    pub const QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES: Self = Self(1000584002i32);
8100    pub const PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES: Self = Self(1000586000i32);
8101    pub const VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO: Self = Self(
8102        1000586001i32,
8103    );
8104    pub const VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO: Self = Self(
8105        1000586002i32,
8106    );
8107    pub const VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO: Self = Self(
8108        1000586003i32,
8109    );
8110    pub const SURFACE_CREATE_INFO: Self = Self(1000685000i32);
8111    pub const PHYSICAL_DEVICE_HDR_VIVID_FEATURES: Self = Self(1000590000i32);
8112    pub const HDR_VIVID_DYNAMIC_METADATA: Self = Self(1000590001i32);
8113    pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES: Self = Self(1000593000i32);
8114    pub const COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES: Self = Self(
8115        1000593001i32,
8116    );
8117    pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES: Self = Self(
8118        1000593002i32,
8119    );
8120    pub const PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES: Self = Self(
8121        1000596000i32,
8122    );
8123    pub const IMPORT_MEMORY_METAL_HANDLE_INFO: Self = Self(1000602000i32);
8124    pub const MEMORY_METAL_HANDLE_PROPERTIES: Self = Self(1000602001i32);
8125    pub const MEMORY_GET_METAL_HANDLE_INFO: Self = Self(1000602002i32);
8126    pub const PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES: Self = Self(
8127        1000605000i32,
8128    );
8129    pub const PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES: Self = Self(
8130        1000605001i32,
8131    );
8132    pub const RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO: Self = Self(
8133        1000605004i32,
8134    );
8135    pub const PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES: Self = Self(
8136        1000607000i32,
8137    );
8138    pub const PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES: Self = Self(
8139        1000607001i32,
8140    );
8141    pub const SHADER_INSTRUMENTATION_CREATE_INFO: Self = Self(1000607002i32);
8142    pub const SHADER_INSTRUMENTATION_METRIC_DESCRIPTION: Self = Self(1000607003i32);
8143    pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES: Self = Self(
8144        1000608000i32,
8145    );
8146    pub const PHYSICAL_DEVICE_FORMAT_PACK_FEATURES: Self = Self(1000609000i32);
8147    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES: Self = Self(
8148        1000611000i32,
8149    );
8150    pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES: Self = Self(
8151        1000611001i32,
8152    );
8153    pub const PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO: Self = Self(
8154        1000611002i32,
8155    );
8156    pub const SET_PRESENT_CONFIG: Self = Self(1000613000i32);
8157    pub const PHYSICAL_DEVICE_PRESENT_METERING_FEATURES: Self = Self(1000613001i32);
8158    pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO: Self = Self(
8159        1000425002i32,
8160    );
8161    pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES: Self = Self(
8162        1000620000i32,
8163    );
8164    pub const PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES: Self = Self(
8165        1000627000i32,
8166    );
8167    pub const PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES: Self = Self(1000628000i32);
8168    pub const BEGIN_CUSTOM_RESOLVE_INFO: Self = Self(1000628001i32);
8169    pub const CUSTOM_RESOLVE_CREATE_INFO: Self = Self(1000628002i32);
8170    pub const PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES: Self = Self(1000629000i32);
8171    pub const DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO: Self = Self(1000629001i32);
8172    pub const PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES: Self = Self(1000630000i32);
8173    pub const PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES: Self = Self(1000630001i32);
8174    pub const RENDERING_ATTACHMENT_FLAGS_INFO: Self = Self(1000630002i32);
8175    pub const RESOLVE_IMAGE_MODE_INFO: Self = Self(1000630004i32);
8176    pub const PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES: Self = Self(1000635000i32);
8177    pub const PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES: Self = Self(1000635001i32);
8178    pub const PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES: Self = Self(
8179        1000637000i32,
8180    );
8181    pub const PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES: Self = Self(
8182        1000642000i32,
8183    );
8184    pub const COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS: Self = Self(1000645000i32);
8185    pub const PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES: Self = Self(
8186        1000645001i32,
8187    );
8188    pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES: Self = Self(
8189        1000662000i32,
8190    );
8191    pub const UBM_SURFACE_CREATE_INFO: Self = Self(1000664000i32);
8192    pub const PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES: Self = Self(
8193        1000673000i32,
8194    );
8195    #[inline]
8196    pub const fn from_raw(value: i32) -> Self {
8197        Self(value)
8198    }
8199    #[inline]
8200    pub const fn as_raw(self) -> i32 {
8201        self.0
8202    }
8203}
8204impl core::fmt::Debug for StructureType {
8205    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
8206        match self.0 {
8207            0i32 => f.write_str("APPLICATION_INFO"),
8208            1i32 => f.write_str("INSTANCE_CREATE_INFO"),
8209            2i32 => f.write_str("DEVICE_QUEUE_CREATE_INFO"),
8210            3i32 => f.write_str("DEVICE_CREATE_INFO"),
8211            4i32 => f.write_str("SUBMIT_INFO"),
8212            5i32 => f.write_str("MEMORY_ALLOCATE_INFO"),
8213            6i32 => f.write_str("MAPPED_MEMORY_RANGE"),
8214            7i32 => f.write_str("BIND_SPARSE_INFO"),
8215            8i32 => f.write_str("FENCE_CREATE_INFO"),
8216            9i32 => f.write_str("SEMAPHORE_CREATE_INFO"),
8217            10i32 => f.write_str("EVENT_CREATE_INFO"),
8218            11i32 => f.write_str("QUERY_POOL_CREATE_INFO"),
8219            12i32 => f.write_str("BUFFER_CREATE_INFO"),
8220            13i32 => f.write_str("BUFFER_VIEW_CREATE_INFO"),
8221            14i32 => f.write_str("IMAGE_CREATE_INFO"),
8222            15i32 => f.write_str("IMAGE_VIEW_CREATE_INFO"),
8223            16i32 => f.write_str("SHADER_MODULE_CREATE_INFO"),
8224            17i32 => f.write_str("PIPELINE_CACHE_CREATE_INFO"),
8225            18i32 => f.write_str("PIPELINE_SHADER_STAGE_CREATE_INFO"),
8226            19i32 => f.write_str("PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO"),
8227            20i32 => f.write_str("PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO"),
8228            21i32 => f.write_str("PIPELINE_TESSELLATION_STATE_CREATE_INFO"),
8229            22i32 => f.write_str("PIPELINE_VIEWPORT_STATE_CREATE_INFO"),
8230            23i32 => f.write_str("PIPELINE_RASTERIZATION_STATE_CREATE_INFO"),
8231            24i32 => f.write_str("PIPELINE_MULTISAMPLE_STATE_CREATE_INFO"),
8232            25i32 => f.write_str("PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO"),
8233            26i32 => f.write_str("PIPELINE_COLOR_BLEND_STATE_CREATE_INFO"),
8234            27i32 => f.write_str("PIPELINE_DYNAMIC_STATE_CREATE_INFO"),
8235            28i32 => f.write_str("GRAPHICS_PIPELINE_CREATE_INFO"),
8236            29i32 => f.write_str("COMPUTE_PIPELINE_CREATE_INFO"),
8237            30i32 => f.write_str("PIPELINE_LAYOUT_CREATE_INFO"),
8238            31i32 => f.write_str("SAMPLER_CREATE_INFO"),
8239            32i32 => f.write_str("DESCRIPTOR_SET_LAYOUT_CREATE_INFO"),
8240            33i32 => f.write_str("DESCRIPTOR_POOL_CREATE_INFO"),
8241            34i32 => f.write_str("DESCRIPTOR_SET_ALLOCATE_INFO"),
8242            35i32 => f.write_str("WRITE_DESCRIPTOR_SET"),
8243            36i32 => f.write_str("COPY_DESCRIPTOR_SET"),
8244            37i32 => f.write_str("FRAMEBUFFER_CREATE_INFO"),
8245            38i32 => f.write_str("RENDER_PASS_CREATE_INFO"),
8246            39i32 => f.write_str("COMMAND_POOL_CREATE_INFO"),
8247            40i32 => f.write_str("COMMAND_BUFFER_ALLOCATE_INFO"),
8248            41i32 => f.write_str("COMMAND_BUFFER_INHERITANCE_INFO"),
8249            42i32 => f.write_str("COMMAND_BUFFER_BEGIN_INFO"),
8250            43i32 => f.write_str("RENDER_PASS_BEGIN_INFO"),
8251            44i32 => f.write_str("BUFFER_MEMORY_BARRIER"),
8252            45i32 => f.write_str("IMAGE_MEMORY_BARRIER"),
8253            46i32 => f.write_str("MEMORY_BARRIER"),
8254            47i32 => f.write_str("LOADER_INSTANCE_CREATE_INFO"),
8255            48i32 => f.write_str("LOADER_DEVICE_CREATE_INFO"),
8256            1000157000i32 => f.write_str("BIND_BUFFER_MEMORY_INFO"),
8257            1000157001i32 => f.write_str("BIND_IMAGE_MEMORY_INFO"),
8258            1000127000i32 => f.write_str("MEMORY_DEDICATED_REQUIREMENTS"),
8259            1000127001i32 => f.write_str("MEMORY_DEDICATED_ALLOCATE_INFO"),
8260            1000060000i32 => f.write_str("MEMORY_ALLOCATE_FLAGS_INFO"),
8261            1000060004i32 => f.write_str("DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO"),
8262            1000060005i32 => f.write_str("DEVICE_GROUP_SUBMIT_INFO"),
8263            1000060006i32 => f.write_str("DEVICE_GROUP_BIND_SPARSE_INFO"),
8264            1000060013i32 => f.write_str("BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO"),
8265            1000060014i32 => f.write_str("BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO"),
8266            1000070000i32 => f.write_str("PHYSICAL_DEVICE_GROUP_PROPERTIES"),
8267            1000070001i32 => f.write_str("DEVICE_GROUP_DEVICE_CREATE_INFO"),
8268            1000146000i32 => f.write_str("BUFFER_MEMORY_REQUIREMENTS_INFO_2"),
8269            1000146001i32 => f.write_str("IMAGE_MEMORY_REQUIREMENTS_INFO_2"),
8270            1000146002i32 => f.write_str("IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2"),
8271            1000146003i32 => f.write_str("MEMORY_REQUIREMENTS_2"),
8272            1000146004i32 => f.write_str("SPARSE_IMAGE_MEMORY_REQUIREMENTS_2"),
8273            1000059000i32 => f.write_str("PHYSICAL_DEVICE_FEATURES_2"),
8274            1000059001i32 => f.write_str("PHYSICAL_DEVICE_PROPERTIES_2"),
8275            1000059002i32 => f.write_str("FORMAT_PROPERTIES_2"),
8276            1000059003i32 => f.write_str("IMAGE_FORMAT_PROPERTIES_2"),
8277            1000059004i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2"),
8278            1000059005i32 => f.write_str("QUEUE_FAMILY_PROPERTIES_2"),
8279            1000059006i32 => f.write_str("PHYSICAL_DEVICE_MEMORY_PROPERTIES_2"),
8280            1000059007i32 => f.write_str("SPARSE_IMAGE_FORMAT_PROPERTIES_2"),
8281            1000059008i32 => f.write_str("PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2"),
8282            1000117002i32 => f.write_str("IMAGE_VIEW_USAGE_CREATE_INFO"),
8283            1000145000i32 => f.write_str("PROTECTED_SUBMIT_INFO"),
8284            1000145001i32 => f.write_str("PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES"),
8285            1000145002i32 => f.write_str("PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES"),
8286            1000145003i32 => f.write_str("DEVICE_QUEUE_INFO_2"),
8287            1000071000i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO"),
8288            1000071001i32 => f.write_str("EXTERNAL_IMAGE_FORMAT_PROPERTIES"),
8289            1000071002i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO"),
8290            1000071003i32 => f.write_str("EXTERNAL_BUFFER_PROPERTIES"),
8291            1000071004i32 => f.write_str("PHYSICAL_DEVICE_ID_PROPERTIES"),
8292            1000072000i32 => f.write_str("EXTERNAL_MEMORY_BUFFER_CREATE_INFO"),
8293            1000072001i32 => f.write_str("EXTERNAL_MEMORY_IMAGE_CREATE_INFO"),
8294            1000072002i32 => f.write_str("EXPORT_MEMORY_ALLOCATE_INFO"),
8295            1000112000i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO"),
8296            1000112001i32 => f.write_str("EXTERNAL_FENCE_PROPERTIES"),
8297            1000113000i32 => f.write_str("EXPORT_FENCE_CREATE_INFO"),
8298            1000077000i32 => f.write_str("EXPORT_SEMAPHORE_CREATE_INFO"),
8299            1000076000i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO"),
8300            1000076001i32 => f.write_str("EXTERNAL_SEMAPHORE_PROPERTIES"),
8301            1000094000i32 => f.write_str("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES"),
8302            1000083000i32 => f.write_str("PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES"),
8303            1000120000i32 => f.write_str("PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES"),
8304            1000085000i32 => f.write_str("DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO"),
8305            1000168000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES"),
8306            1000168001i32 => f.write_str("DESCRIPTOR_SET_LAYOUT_SUPPORT"),
8307            1000156000i32 => f.write_str("SAMPLER_YCBCR_CONVERSION_CREATE_INFO"),
8308            1000156001i32 => f.write_str("SAMPLER_YCBCR_CONVERSION_INFO"),
8309            1000156002i32 => f.write_str("BIND_IMAGE_PLANE_MEMORY_INFO"),
8310            1000156003i32 => f.write_str("IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO"),
8311            1000156004i32 => {
8312                f.write_str("PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES")
8313            }
8314            1000156005i32 => {
8315                f.write_str("SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES")
8316            }
8317            1000060003i32 => f.write_str("DEVICE_GROUP_RENDER_PASS_BEGIN_INFO"),
8318            1000117000i32 => f.write_str("PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES"),
8319            1000117001i32 => {
8320                f.write_str("RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO")
8321            }
8322            1000117003i32 => {
8323                f.write_str("PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO")
8324            }
8325            1000053000i32 => f.write_str("RENDER_PASS_MULTIVIEW_CREATE_INFO"),
8326            1000053001i32 => f.write_str("PHYSICAL_DEVICE_MULTIVIEW_FEATURES"),
8327            1000053002i32 => f.write_str("PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES"),
8328            1000063000i32 => {
8329                f.write_str("PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES")
8330            }
8331            1000196000i32 => f.write_str("PHYSICAL_DEVICE_DRIVER_PROPERTIES"),
8332            49i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_1_FEATURES"),
8333            50i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES"),
8334            51i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_2_FEATURES"),
8335            52i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES"),
8336            1000147000i32 => f.write_str("IMAGE_FORMAT_LIST_CREATE_INFO"),
8337            1000211000i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES"),
8338            1000261000i32 => f.write_str("PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES"),
8339            1000207000i32 => f.write_str("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES"),
8340            1000207001i32 => f.write_str("PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES"),
8341            1000207002i32 => f.write_str("SEMAPHORE_TYPE_CREATE_INFO"),
8342            1000207003i32 => f.write_str("TIMELINE_SEMAPHORE_SUBMIT_INFO"),
8343            1000207004i32 => f.write_str("SEMAPHORE_WAIT_INFO"),
8344            1000207005i32 => f.write_str("SEMAPHORE_SIGNAL_INFO"),
8345            1000257000i32 => {
8346                f.write_str("PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES")
8347            }
8348            1000244001i32 => f.write_str("BUFFER_DEVICE_ADDRESS_INFO"),
8349            1000257002i32 => f.write_str("BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO"),
8350            1000257003i32 => f.write_str("MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO"),
8351            1000257004i32 => f.write_str("DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO"),
8352            1000177000i32 => f.write_str("PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES"),
8353            1000180000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES"),
8354            1000082000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES"),
8355            1000197000i32 => f.write_str("PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES"),
8356            1000161000i32 => {
8357                f.write_str("DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO")
8358            }
8359            1000161001i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES"),
8360            1000161002i32 => {
8361                f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES")
8362            }
8363            1000161003i32 => {
8364                f.write_str("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO")
8365            }
8366            1000161004i32 => {
8367                f.write_str("DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT")
8368            }
8369            1000221000i32 => f.write_str("PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES"),
8370            1000130000i32 => {
8371                f.write_str("PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES")
8372            }
8373            1000130001i32 => f.write_str("SAMPLER_REDUCTION_MODE_CREATE_INFO"),
8374            1000253000i32 => {
8375                f.write_str("PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES")
8376            }
8377            1000175000i32 => {
8378                f.write_str("PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES")
8379            }
8380            1000109000i32 => f.write_str("ATTACHMENT_DESCRIPTION_2"),
8381            1000109001i32 => f.write_str("ATTACHMENT_REFERENCE_2"),
8382            1000109002i32 => f.write_str("SUBPASS_DESCRIPTION_2"),
8383            1000109003i32 => f.write_str("SUBPASS_DEPENDENCY_2"),
8384            1000109004i32 => f.write_str("RENDER_PASS_CREATE_INFO_2"),
8385            1000109005i32 => f.write_str("SUBPASS_BEGIN_INFO"),
8386            1000109006i32 => f.write_str("SUBPASS_END_INFO"),
8387            1000199000i32 => {
8388                f.write_str("PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES")
8389            }
8390            1000199001i32 => f.write_str("SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE"),
8391            1000246000i32 => f.write_str("IMAGE_STENCIL_USAGE_CREATE_INFO"),
8392            1000108000i32 => {
8393                f.write_str("PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES")
8394            }
8395            1000108001i32 => f.write_str("FRAMEBUFFER_ATTACHMENTS_CREATE_INFO"),
8396            1000108002i32 => f.write_str("FRAMEBUFFER_ATTACHMENT_IMAGE_INFO"),
8397            1000108003i32 => f.write_str("RENDER_PASS_ATTACHMENT_BEGIN_INFO"),
8398            1000241000i32 => {
8399                f.write_str("PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES")
8400            }
8401            1000241001i32 => f.write_str("ATTACHMENT_REFERENCE_STENCIL_LAYOUT"),
8402            1000241002i32 => f.write_str("ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT"),
8403            53i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_3_FEATURES"),
8404            54i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES"),
8405            1000245000i32 => f.write_str("PHYSICAL_DEVICE_TOOL_PROPERTIES"),
8406            1000295000i32 => f.write_str("PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES"),
8407            1000295001i32 => f.write_str("DEVICE_PRIVATE_DATA_CREATE_INFO"),
8408            1000295002i32 => f.write_str("PRIVATE_DATA_SLOT_CREATE_INFO"),
8409            1000314000i32 => f.write_str("MEMORY_BARRIER_2"),
8410            1000314001i32 => f.write_str("BUFFER_MEMORY_BARRIER_2"),
8411            1000314002i32 => f.write_str("IMAGE_MEMORY_BARRIER_2"),
8412            1000314003i32 => f.write_str("DEPENDENCY_INFO"),
8413            1000314004i32 => f.write_str("SUBMIT_INFO_2"),
8414            1000314005i32 => f.write_str("SEMAPHORE_SUBMIT_INFO"),
8415            1000314006i32 => f.write_str("COMMAND_BUFFER_SUBMIT_INFO"),
8416            1000314007i32 => f.write_str("PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES"),
8417            1000337000i32 => f.write_str("COPY_BUFFER_INFO_2"),
8418            1000337001i32 => f.write_str("COPY_IMAGE_INFO_2"),
8419            1000337002i32 => f.write_str("COPY_BUFFER_TO_IMAGE_INFO_2"),
8420            1000337003i32 => f.write_str("COPY_IMAGE_TO_BUFFER_INFO_2"),
8421            1000337006i32 => f.write_str("BUFFER_COPY_2"),
8422            1000337007i32 => f.write_str("IMAGE_COPY_2"),
8423            1000337009i32 => f.write_str("BUFFER_IMAGE_COPY_2"),
8424            1000066000i32 => {
8425                f.write_str("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES")
8426            }
8427            1000360000i32 => f.write_str("FORMAT_PROPERTIES_3"),
8428            1000413000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES"),
8429            1000413001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES"),
8430            1000413002i32 => f.write_str("DEVICE_BUFFER_MEMORY_REQUIREMENTS"),
8431            1000413003i32 => f.write_str("DEVICE_IMAGE_MEMORY_REQUIREMENTS"),
8432            1000192000i32 => f.write_str("PIPELINE_CREATION_FEEDBACK_CREATE_INFO"),
8433            1000215000i32 => {
8434                f.write_str("PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES")
8435            }
8436            1000276000i32 => {
8437                f.write_str(
8438                    "PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES",
8439                )
8440            }
8441            1000297000i32 => {
8442                f.write_str("PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES")
8443            }
8444            1000325000i32 => {
8445                f.write_str("PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES")
8446            }
8447            1000335000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES"),
8448            1000225000i32 => {
8449                f.write_str("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES")
8450            }
8451            1000225001i32 => {
8452                f.write_str("PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO")
8453            }
8454            1000225002i32 => {
8455                f.write_str("PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES")
8456            }
8457            1000138000i32 => f.write_str("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES"),
8458            1000138001i32 => {
8459                f.write_str("PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES")
8460            }
8461            1000138002i32 => f.write_str("WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK"),
8462            1000138003i32 => {
8463                f.write_str("DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO")
8464            }
8465            1000280000i32 => {
8466                f.write_str("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES")
8467            }
8468            1000280001i32 => {
8469                f.write_str("PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES")
8470            }
8471            1000281001i32 => {
8472                f.write_str("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES")
8473            }
8474            1000337004i32 => f.write_str("BLIT_IMAGE_INFO_2"),
8475            1000337005i32 => f.write_str("RESOLVE_IMAGE_INFO_2"),
8476            1000337008i32 => f.write_str("IMAGE_BLIT_2"),
8477            1000337010i32 => f.write_str("IMAGE_RESOLVE_2"),
8478            1000044000i32 => f.write_str("RENDERING_INFO"),
8479            1000044001i32 => f.write_str("RENDERING_ATTACHMENT_INFO"),
8480            1000044002i32 => f.write_str("PIPELINE_RENDERING_CREATE_INFO"),
8481            1000044003i32 => f.write_str("PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES"),
8482            1000044004i32 => f.write_str("COMMAND_BUFFER_INHERITANCE_RENDERING_INFO"),
8483            55i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_4_FEATURES"),
8484            56i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES"),
8485            1000174000i32 => f.write_str("DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO"),
8486            1000388000i32 => {
8487                f.write_str("PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES")
8488            }
8489            1000388001i32 => f.write_str("QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES"),
8490            1000265000i32 => f.write_str("PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES"),
8491            1000271000i32 => f.write_str("MEMORY_MAP_INFO"),
8492            1000271001i32 => f.write_str("MEMORY_UNMAP_INFO"),
8493            1000470000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES"),
8494            1000470001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES"),
8495            1000470004i32 => f.write_str("DEVICE_IMAGE_SUBRESOURCE_INFO"),
8496            1000338002i32 => f.write_str("SUBRESOURCE_LAYOUT_2"),
8497            1000338003i32 => f.write_str("IMAGE_SUBRESOURCE_2"),
8498            1000470006i32 => f.write_str("BUFFER_USAGE_FLAGS_2_CREATE_INFO"),
8499            1000545000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES"),
8500            1000545001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES"),
8501            1000545002i32 => f.write_str("BIND_MEMORY_STATUS"),
8502            1000270000i32 => f.write_str("PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES"),
8503            1000270001i32 => f.write_str("PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES"),
8504            1000270002i32 => f.write_str("MEMORY_TO_IMAGE_COPY"),
8505            1000270003i32 => f.write_str("IMAGE_TO_MEMORY_COPY"),
8506            1000270004i32 => f.write_str("COPY_IMAGE_TO_MEMORY_INFO"),
8507            1000270005i32 => f.write_str("COPY_MEMORY_TO_IMAGE_INFO"),
8508            1000270006i32 => f.write_str("HOST_IMAGE_LAYOUT_TRANSITION_INFO"),
8509            1000270007i32 => f.write_str("COPY_IMAGE_TO_IMAGE_INFO"),
8510            1000270008i32 => f.write_str("SUBRESOURCE_HOST_MEMCPY_SIZE"),
8511            1000270009i32 => f.write_str("HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY"),
8512            1000416000i32 => {
8513                f.write_str("PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES")
8514            }
8515            1000528000i32 => {
8516                f.write_str("PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES")
8517            }
8518            1000544000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES"),
8519            1000470005i32 => f.write_str("PIPELINE_CREATE_FLAGS_2_CREATE_INFO"),
8520            1000080000i32 => f.write_str("PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES"),
8521            1000545003i32 => f.write_str("BIND_DESCRIPTOR_SETS_INFO"),
8522            1000545004i32 => f.write_str("PUSH_CONSTANTS_INFO"),
8523            1000545005i32 => f.write_str("PUSH_DESCRIPTOR_SET_INFO"),
8524            1000545006i32 => f.write_str("PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO"),
8525            1000466000i32 => {
8526                f.write_str("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES")
8527            }
8528            1000068000i32 => f.write_str("PIPELINE_ROBUSTNESS_CREATE_INFO"),
8529            1000068001i32 => f.write_str("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES"),
8530            1000068002i32 => {
8531                f.write_str("PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES")
8532            }
8533            1000259000i32 => f.write_str("PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES"),
8534            1000259001i32 => f.write_str("PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO"),
8535            1000259002i32 => f.write_str("PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES"),
8536            1000525000i32 => {
8537                f.write_str("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES")
8538            }
8539            1000190001i32 => {
8540                f.write_str("PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO")
8541            }
8542            1000190002i32 => {
8543                f.write_str("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES")
8544            }
8545            1000470003i32 => f.write_str("RENDERING_AREA_INFO"),
8546            1000232000i32 => {
8547                f.write_str("PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES")
8548            }
8549            1000232001i32 => f.write_str("RENDERING_ATTACHMENT_LOCATION_INFO"),
8550            1000232002i32 => f.write_str("RENDERING_INPUT_ATTACHMENT_INDEX_INFO"),
8551            1000298000i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES"),
8552            1000298001i32 => f.write_str("PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES"),
8553            1000298002i32 => f.write_str("DEVICE_OBJECT_RESERVATION_CREATE_INFO"),
8554            1000298003i32 => f.write_str("COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO"),
8555            1000298004i32 => f.write_str("COMMAND_POOL_MEMORY_CONSUMPTION"),
8556            1000298005i32 => f.write_str("PIPELINE_POOL_SIZE"),
8557            1000298007i32 => f.write_str("FAULT_DATA"),
8558            1000298008i32 => f.write_str("FAULT_CALLBACK_INFO"),
8559            1000298010i32 => f.write_str("PIPELINE_OFFLINE_CREATE_INFO"),
8560            1000001000i32 => f.write_str("SWAPCHAIN_CREATE_INFO"),
8561            1000001001i32 => f.write_str("PRESENT_INFO"),
8562            1000060007i32 => f.write_str("DEVICE_GROUP_PRESENT_CAPABILITIES"),
8563            1000060008i32 => f.write_str("IMAGE_SWAPCHAIN_CREATE_INFO"),
8564            1000060009i32 => f.write_str("BIND_IMAGE_MEMORY_SWAPCHAIN_INFO"),
8565            1000060010i32 => f.write_str("ACQUIRE_NEXT_IMAGE_INFO"),
8566            1000060011i32 => f.write_str("DEVICE_GROUP_PRESENT_INFO"),
8567            1000060012i32 => f.write_str("DEVICE_GROUP_SWAPCHAIN_CREATE_INFO"),
8568            1000002000i32 => f.write_str("DISPLAY_MODE_CREATE_INFO"),
8569            1000002001i32 => f.write_str("DISPLAY_SURFACE_CREATE_INFO"),
8570            1000003000i32 => f.write_str("DISPLAY_PRESENT_INFO"),
8571            1000004000i32 => f.write_str("XLIB_SURFACE_CREATE_INFO"),
8572            1000005000i32 => f.write_str("XCB_SURFACE_CREATE_INFO"),
8573            1000006000i32 => f.write_str("WAYLAND_SURFACE_CREATE_INFO"),
8574            1000008000i32 => f.write_str("ANDROID_SURFACE_CREATE_INFO"),
8575            1000009000i32 => f.write_str("WIN32_SURFACE_CREATE_INFO"),
8576            1000011000i32 => f.write_str("DEBUG_REPORT_CALLBACK_CREATE_INFO"),
8577            1000018000i32 => {
8578                f.write_str("PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER")
8579            }
8580            1000022000i32 => f.write_str("DEBUG_MARKER_OBJECT_NAME_INFO"),
8581            1000022001i32 => f.write_str("DEBUG_MARKER_OBJECT_TAG_INFO"),
8582            1000022002i32 => f.write_str("DEBUG_MARKER_MARKER_INFO"),
8583            1000023000i32 => f.write_str("VIDEO_PROFILE_INFO"),
8584            1000023001i32 => f.write_str("VIDEO_CAPABILITIES"),
8585            1000023002i32 => f.write_str("VIDEO_PICTURE_RESOURCE_INFO"),
8586            1000023003i32 => f.write_str("VIDEO_SESSION_MEMORY_REQUIREMENTS"),
8587            1000023004i32 => f.write_str("BIND_VIDEO_SESSION_MEMORY_INFO"),
8588            1000023005i32 => f.write_str("VIDEO_SESSION_CREATE_INFO"),
8589            1000023006i32 => f.write_str("VIDEO_SESSION_PARAMETERS_CREATE_INFO"),
8590            1000023007i32 => f.write_str("VIDEO_SESSION_PARAMETERS_UPDATE_INFO"),
8591            1000023008i32 => f.write_str("VIDEO_BEGIN_CODING_INFO"),
8592            1000023009i32 => f.write_str("VIDEO_END_CODING_INFO"),
8593            1000023010i32 => f.write_str("VIDEO_CODING_CONTROL_INFO"),
8594            1000023011i32 => f.write_str("VIDEO_REFERENCE_SLOT_INFO"),
8595            1000023012i32 => f.write_str("QUEUE_FAMILY_VIDEO_PROPERTIES"),
8596            1000023013i32 => f.write_str("VIDEO_PROFILE_LIST_INFO"),
8597            1000023014i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_FORMAT_INFO"),
8598            1000023015i32 => f.write_str("VIDEO_FORMAT_PROPERTIES"),
8599            1000023016i32 => f.write_str("QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES"),
8600            1000024000i32 => f.write_str("VIDEO_DECODE_INFO"),
8601            1000024001i32 => f.write_str("VIDEO_DECODE_CAPABILITIES"),
8602            1000024002i32 => f.write_str("VIDEO_DECODE_USAGE_INFO"),
8603            1000026000i32 => f.write_str("DEDICATED_ALLOCATION_IMAGE_CREATE_INFO"),
8604            1000026001i32 => f.write_str("DEDICATED_ALLOCATION_BUFFER_CREATE_INFO"),
8605            1000026002i32 => f.write_str("DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO"),
8606            1000028000i32 => f.write_str("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES"),
8607            1000028001i32 => f.write_str("PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES"),
8608            1000028002i32 => {
8609                f.write_str("PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO")
8610            }
8611            1000029000i32 => f.write_str("CU_MODULE_CREATE_INFO"),
8612            1000029001i32 => f.write_str("CU_FUNCTION_CREATE_INFO"),
8613            1000029002i32 => f.write_str("CU_LAUNCH_INFO"),
8614            1000029004i32 => f.write_str("CU_MODULE_TEXTURING_MODE_CREATE_INFO"),
8615            1000030000i32 => f.write_str("IMAGE_VIEW_HANDLE_INFO"),
8616            1000030001i32 => f.write_str("IMAGE_VIEW_ADDRESS_PROPERTIES"),
8617            1000038000i32 => f.write_str("VIDEO_ENCODE_H264_CAPABILITIES"),
8618            1000038001i32 => {
8619                f.write_str("VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO")
8620            }
8621            1000038002i32 => f.write_str("VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO"),
8622            1000038003i32 => f.write_str("VIDEO_ENCODE_H264_PICTURE_INFO"),
8623            1000038004i32 => f.write_str("VIDEO_ENCODE_H264_DPB_SLOT_INFO"),
8624            1000038005i32 => f.write_str("VIDEO_ENCODE_H264_NALU_SLICE_INFO"),
8625            1000038006i32 => f.write_str("VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO"),
8626            1000038007i32 => f.write_str("VIDEO_ENCODE_H264_PROFILE_INFO"),
8627            1000038008i32 => f.write_str("VIDEO_ENCODE_H264_RATE_CONTROL_INFO"),
8628            1000038009i32 => f.write_str("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO"),
8629            1000038010i32 => f.write_str("VIDEO_ENCODE_H264_SESSION_CREATE_INFO"),
8630            1000038011i32 => f.write_str("VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES"),
8631            1000038012i32 => f.write_str("VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO"),
8632            1000038013i32 => {
8633                f.write_str("VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO")
8634            }
8635            1000039000i32 => f.write_str("VIDEO_ENCODE_H265_CAPABILITIES"),
8636            1000039001i32 => {
8637                f.write_str("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO")
8638            }
8639            1000039002i32 => f.write_str("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO"),
8640            1000039003i32 => f.write_str("VIDEO_ENCODE_H265_PICTURE_INFO"),
8641            1000039004i32 => f.write_str("VIDEO_ENCODE_H265_DPB_SLOT_INFO"),
8642            1000039005i32 => f.write_str("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO"),
8643            1000039006i32 => f.write_str("VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO"),
8644            1000039007i32 => f.write_str("VIDEO_ENCODE_H265_PROFILE_INFO"),
8645            1000039009i32 => f.write_str("VIDEO_ENCODE_H265_RATE_CONTROL_INFO"),
8646            1000039010i32 => f.write_str("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO"),
8647            1000039011i32 => f.write_str("VIDEO_ENCODE_H265_SESSION_CREATE_INFO"),
8648            1000039012i32 => f.write_str("VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES"),
8649            1000039013i32 => f.write_str("VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO"),
8650            1000039014i32 => {
8651                f.write_str("VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO")
8652            }
8653            1000040000i32 => f.write_str("VIDEO_DECODE_H264_CAPABILITIES"),
8654            1000040001i32 => f.write_str("VIDEO_DECODE_H264_PICTURE_INFO"),
8655            1000040003i32 => f.write_str("VIDEO_DECODE_H264_PROFILE_INFO"),
8656            1000040004i32 => {
8657                f.write_str("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO")
8658            }
8659            1000040005i32 => f.write_str("VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO"),
8660            1000040006i32 => f.write_str("VIDEO_DECODE_H264_DPB_SLOT_INFO"),
8661            1000041000i32 => f.write_str("TEXTURE_LOD_GATHER_FORMAT_PROPERTIES"),
8662            1000049000i32 => f.write_str("STREAM_DESCRIPTOR_SURFACE_CREATE_INFO"),
8663            1000050000i32 => f.write_str("PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES"),
8664            1000057000i32 => f.write_str("IMPORT_MEMORY_WIN32_HANDLE_INFO"),
8665            1000057001i32 => f.write_str("EXPORT_MEMORY_WIN32_HANDLE_INFO"),
8666            1000058000i32 => f.write_str("WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO"),
8667            1000061000i32 => f.write_str("VALIDATION_FLAGS"),
8668            1000062000i32 => f.write_str("VI_SURFACE_CREATE_INFO"),
8669            1000067000i32 => f.write_str("IMAGE_VIEW_ASTC_DECODE_MODE"),
8670            1000067001i32 => f.write_str("PHYSICAL_DEVICE_ASTC_DECODE_FEATURES"),
8671            1000073002i32 => f.write_str("MEMORY_WIN32_HANDLE_PROPERTIES"),
8672            1000073003i32 => f.write_str("MEMORY_GET_WIN32_HANDLE_INFO"),
8673            1000074000i32 => f.write_str("IMPORT_MEMORY_FD_INFO"),
8674            1000074001i32 => f.write_str("MEMORY_FD_PROPERTIES"),
8675            1000074002i32 => f.write_str("MEMORY_GET_FD_INFO"),
8676            1000078000i32 => f.write_str("IMPORT_SEMAPHORE_WIN32_HANDLE_INFO"),
8677            1000078001i32 => f.write_str("EXPORT_SEMAPHORE_WIN32_HANDLE_INFO"),
8678            1000078002i32 => f.write_str("D3D12_FENCE_SUBMIT_INFO"),
8679            1000078003i32 => f.write_str("SEMAPHORE_GET_WIN32_HANDLE_INFO"),
8680            1000079000i32 => f.write_str("IMPORT_SEMAPHORE_FD_INFO"),
8681            1000079001i32 => f.write_str("SEMAPHORE_GET_FD_INFO"),
8682            1000081000i32 => {
8683                f.write_str("COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO")
8684            }
8685            1000081001i32 => {
8686                f.write_str("PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES")
8687            }
8688            1000081002i32 => f.write_str("CONDITIONAL_RENDERING_BEGIN_INFO"),
8689            1000084000i32 => f.write_str("PRESENT_REGIONS"),
8690            1000087000i32 => f.write_str("PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO"),
8691            1000090000i32 => f.write_str("SURFACE_CAPABILITIES_2"),
8692            1000091000i32 => f.write_str("DISPLAY_POWER_INFO"),
8693            1000091001i32 => f.write_str("DEVICE_EVENT_INFO"),
8694            1000091002i32 => f.write_str("DISPLAY_EVENT_INFO"),
8695            1000091003i32 => f.write_str("SWAPCHAIN_COUNTER_CREATE_INFO"),
8696            1000092000i32 => f.write_str("PRESENT_TIMES_INFO"),
8697            1000097000i32 => {
8698                f.write_str("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES")
8699            }
8700            1000044009i32 => f.write_str("MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO"),
8701            1000098000i32 => f.write_str("PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO"),
8702            1000099000i32 => f.write_str("PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES"),
8703            1000099001i32 => f.write_str("PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO"),
8704            1000101000i32 => {
8705                f.write_str("PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES")
8706            }
8707            1000101001i32 => {
8708                f.write_str("PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO")
8709            }
8710            1000102000i32 => f.write_str("PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES"),
8711            1000102001i32 => {
8712                f.write_str("PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO")
8713            }
8714            1000105000i32 => f.write_str("HDR_METADATA"),
8715            1000110000i32 => {
8716                f.write_str("PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES")
8717            }
8718            1000111000i32 => f.write_str("SHARED_PRESENT_SURFACE_CAPABILITIES"),
8719            1000114000i32 => f.write_str("IMPORT_FENCE_WIN32_HANDLE_INFO"),
8720            1000114001i32 => f.write_str("EXPORT_FENCE_WIN32_HANDLE_INFO"),
8721            1000114002i32 => f.write_str("FENCE_GET_WIN32_HANDLE_INFO"),
8722            1000115000i32 => f.write_str("IMPORT_FENCE_FD_INFO"),
8723            1000115001i32 => f.write_str("FENCE_GET_FD_INFO"),
8724            1000116000i32 => f.write_str("PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES"),
8725            1000116001i32 => f.write_str("PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES"),
8726            1000116002i32 => f.write_str("QUERY_POOL_PERFORMANCE_CREATE_INFO"),
8727            1000116003i32 => f.write_str("PERFORMANCE_QUERY_SUBMIT_INFO"),
8728            1000116004i32 => f.write_str("ACQUIRE_PROFILING_LOCK_INFO"),
8729            1000116005i32 => f.write_str("PERFORMANCE_COUNTER"),
8730            1000116006i32 => f.write_str("PERFORMANCE_COUNTER_DESCRIPTION"),
8731            1000116007i32 => f.write_str("PERFORMANCE_QUERY_RESERVATION_INFO"),
8732            1000119000i32 => f.write_str("PHYSICAL_DEVICE_SURFACE_INFO_2"),
8733            1000119002i32 => f.write_str("SURFACE_FORMAT_2"),
8734            1000121000i32 => f.write_str("DISPLAY_PROPERTIES_2"),
8735            1000121001i32 => f.write_str("DISPLAY_PLANE_PROPERTIES_2"),
8736            1000121002i32 => f.write_str("DISPLAY_MODE_PROPERTIES_2"),
8737            1000121003i32 => f.write_str("DISPLAY_PLANE_INFO_2"),
8738            1000121004i32 => f.write_str("DISPLAY_PLANE_CAPABILITIES_2"),
8739            1000122000i32 => f.write_str("IOS_SURFACE_CREATE_INFO"),
8740            1000123000i32 => f.write_str("MACOS_SURFACE_CREATE_INFO"),
8741            1000128000i32 => f.write_str("DEBUG_UTILS_OBJECT_NAME_INFO"),
8742            1000128001i32 => f.write_str("DEBUG_UTILS_OBJECT_TAG_INFO"),
8743            1000128002i32 => f.write_str("DEBUG_UTILS_LABEL"),
8744            1000128003i32 => f.write_str("DEBUG_UTILS_MESSENGER_CALLBACK_DATA"),
8745            1000128004i32 => f.write_str("DEBUG_UTILS_MESSENGER_CREATE_INFO"),
8746            1000129000i32 => f.write_str("ANDROID_HARDWARE_BUFFER_USAGE"),
8747            1000129001i32 => f.write_str("ANDROID_HARDWARE_BUFFER_PROPERTIES"),
8748            1000129002i32 => f.write_str("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES"),
8749            1000129003i32 => f.write_str("IMPORT_ANDROID_HARDWARE_BUFFER_INFO"),
8750            1000129004i32 => f.write_str("MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO"),
8751            1000129005i32 => f.write_str("EXTERNAL_FORMAT"),
8752            1000129006i32 => f.write_str("ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2"),
8753            1000134000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES"),
8754            1000134001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES"),
8755            1000134002i32 => f.write_str("EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE"),
8756            1000134003i32 => f.write_str("EXECUTION_GRAPH_PIPELINE_CREATE_INFO"),
8757            1000134004i32 => f.write_str("PIPELINE_SHADER_STAGE_NODE_CREATE_INFO"),
8758            1000135000i32 => f.write_str("TEXEL_BUFFER_DESCRIPTOR_INFO"),
8759            1000135001i32 => f.write_str("IMAGE_DESCRIPTOR_INFO"),
8760            1000135002i32 => f.write_str("RESOURCE_DESCRIPTOR_INFO"),
8761            1000135003i32 => f.write_str("BIND_HEAP_INFO"),
8762            1000135004i32 => f.write_str("PUSH_DATA_INFO"),
8763            1000135005i32 => f.write_str("DESCRIPTOR_SET_AND_BINDING_MAPPING"),
8764            1000135006i32 => {
8765                f.write_str("SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO")
8766            }
8767            1000135007i32 => f.write_str("OPAQUE_CAPTURE_DATA_CREATE_INFO"),
8768            1000135008i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES"),
8769            1000135009i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES"),
8770            1000135010i32 => {
8771                f.write_str("COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO")
8772            }
8773            1000135011i32 => f.write_str("SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO"),
8774            1000135012i32 => f.write_str("INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN"),
8775            1000135013i32 => f.write_str("SUBSAMPLED_IMAGE_FORMAT_PROPERTIES"),
8776            1000135014i32 => {
8777                f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES")
8778            }
8779            1000044008i32 => f.write_str("ATTACHMENT_SAMPLE_COUNT_INFO"),
8780            1000141000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES"),
8781            1000143000i32 => f.write_str("SAMPLE_LOCATIONS_INFO"),
8782            1000143001i32 => f.write_str("RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO"),
8783            1000143002i32 => f.write_str("PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO"),
8784            1000143003i32 => f.write_str("PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES"),
8785            1000143004i32 => f.write_str("MULTISAMPLE_PROPERTIES"),
8786            1000148000i32 => {
8787                f.write_str("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES")
8788            }
8789            1000148001i32 => {
8790                f.write_str("PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES")
8791            }
8792            1000148002i32 => {
8793                f.write_str("PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO")
8794            }
8795            1000149000i32 => f.write_str("PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO"),
8796            1000150007i32 => f.write_str("WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE"),
8797            1000150000i32 => f.write_str("ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO"),
8798            1000150002i32 => f.write_str("ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO"),
8799            1000150003i32 => f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA"),
8800            1000150004i32 => {
8801                f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA")
8802            }
8803            1000150005i32 => {
8804                f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA")
8805            }
8806            1000150006i32 => f.write_str("ACCELERATION_STRUCTURE_GEOMETRY"),
8807            1000150009i32 => f.write_str("ACCELERATION_STRUCTURE_VERSION_INFO"),
8808            1000150010i32 => f.write_str("COPY_ACCELERATION_STRUCTURE_INFO"),
8809            1000150011i32 => f.write_str("COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO"),
8810            1000150012i32 => f.write_str("COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO"),
8811            1000150013i32 => {
8812                f.write_str("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES")
8813            }
8814            1000150014i32 => {
8815                f.write_str("PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES")
8816            }
8817            1000150017i32 => f.write_str("ACCELERATION_STRUCTURE_CREATE_INFO"),
8818            1000150020i32 => f.write_str("ACCELERATION_STRUCTURE_BUILD_SIZES_INFO"),
8819            1000347000i32 => f.write_str("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES"),
8820            1000347001i32 => {
8821                f.write_str("PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES")
8822            }
8823            1000150015i32 => f.write_str("RAY_TRACING_PIPELINE_CREATE_INFO"),
8824            1000150016i32 => f.write_str("RAY_TRACING_SHADER_GROUP_CREATE_INFO"),
8825            1000150018i32 => f.write_str("RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO"),
8826            1000348013i32 => f.write_str("PHYSICAL_DEVICE_RAY_QUERY_FEATURES"),
8827            1000152000i32 => {
8828                f.write_str("PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO")
8829            }
8830            1000154000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES"),
8831            1000154001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES"),
8832            1000158000i32 => f.write_str("DRM_FORMAT_MODIFIER_PROPERTIES_LIST"),
8833            1000158002i32 => {
8834                f.write_str("PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO")
8835            }
8836            1000158003i32 => f.write_str("IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO"),
8837            1000158004i32 => {
8838                f.write_str("IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO")
8839            }
8840            1000158005i32 => f.write_str("IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES"),
8841            1000158006i32 => f.write_str("DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2"),
8842            1000160000i32 => f.write_str("VALIDATION_CACHE_CREATE_INFO"),
8843            1000160001i32 => f.write_str("SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO"),
8844            1000163000i32 => f.write_str("PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES"),
8845            1000163001i32 => f.write_str("PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES"),
8846            1000164000i32 => {
8847                f.write_str("PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO")
8848            }
8849            1000164001i32 => f.write_str("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES"),
8850            1000164002i32 => f.write_str("PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES"),
8851            1000164005i32 => {
8852                f.write_str("PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO")
8853            }
8854            1000165003i32 => f.write_str("GEOMETRY"),
8855            1000165004i32 => f.write_str("GEOMETRY_TRIANGLES"),
8856            1000165005i32 => f.write_str("GEOMETRY_AABB"),
8857            1000165006i32 => f.write_str("BIND_ACCELERATION_STRUCTURE_MEMORY_INFO"),
8858            1000165008i32 => {
8859                f.write_str("ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO")
8860            }
8861            1000165009i32 => f.write_str("PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES"),
8862            1000165012i32 => f.write_str("ACCELERATION_STRUCTURE_INFO"),
8863            1000166000i32 => {
8864                f.write_str("PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES")
8865            }
8866            1000166001i32 => {
8867                f.write_str("PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO")
8868            }
8869            1000170000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO"),
8870            1000170001i32 => {
8871                f.write_str("FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES")
8872            }
8873            1000172000i32 => {
8874                f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES")
8875            }
8876            1000178000i32 => f.write_str("IMPORT_MEMORY_HOST_POINTER_INFO"),
8877            1000178001i32 => f.write_str("MEMORY_HOST_POINTER_PROPERTIES"),
8878            1000178002i32 => {
8879                f.write_str("PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES")
8880            }
8881            1000181000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES"),
8882            1000183000i32 => f.write_str("PIPELINE_COMPILER_CONTROL_CREATE_INFO"),
8883            1000185000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES"),
8884            1000187000i32 => f.write_str("VIDEO_DECODE_H265_CAPABILITIES"),
8885            1000187001i32 => {
8886                f.write_str("VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO")
8887            }
8888            1000187002i32 => f.write_str("VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO"),
8889            1000187003i32 => f.write_str("VIDEO_DECODE_H265_PROFILE_INFO"),
8890            1000187004i32 => f.write_str("VIDEO_DECODE_H265_PICTURE_INFO"),
8891            1000187005i32 => f.write_str("VIDEO_DECODE_H265_DPB_SLOT_INFO"),
8892            1000189000i32 => f.write_str("DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO"),
8893            1000191000i32 => f.write_str("PRESENT_FRAME_TOKEN"),
8894            1000202000i32 => f.write_str("PHYSICAL_DEVICE_MESH_SHADER_FEATURES"),
8895            1000202001i32 => f.write_str("PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES"),
8896            1000204000i32 => {
8897                f.write_str("PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES")
8898            }
8899            1000205000i32 => {
8900                f.write_str("PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO")
8901            }
8902            1000205002i32 => f.write_str("PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES"),
8903            1000206000i32 => f.write_str("CHECKPOINT_DATA"),
8904            1000206001i32 => f.write_str("QUEUE_FAMILY_CHECKPOINT_PROPERTIES"),
8905            1000314008i32 => f.write_str("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2"),
8906            1000314009i32 => f.write_str("CHECKPOINT_DATA_2"),
8907            1000208000i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES"),
8908            1000208001i32 => f.write_str("SWAPCHAIN_TIMING_PROPERTIES"),
8909            1000208002i32 => f.write_str("SWAPCHAIN_TIME_DOMAIN_PROPERTIES"),
8910            1000208003i32 => f.write_str("PRESENT_TIMINGS_INFO"),
8911            1000208004i32 => f.write_str("PRESENT_TIMING_INFO"),
8912            1000208005i32 => f.write_str("PAST_PRESENTATION_TIMING_INFO"),
8913            1000208006i32 => f.write_str("PAST_PRESENTATION_TIMING_PROPERTIES"),
8914            1000208007i32 => f.write_str("PAST_PRESENTATION_TIMING"),
8915            1000208008i32 => f.write_str("PRESENT_TIMING_SURFACE_CAPABILITIES"),
8916            1000208009i32 => f.write_str("SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO"),
8917            1000209000i32 => {
8918                f.write_str("PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES")
8919            }
8920            1000210000i32 => f.write_str("QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO"),
8921            1000210001i32 => f.write_str("INITIALIZE_PERFORMANCE_API_INFO"),
8922            1000210002i32 => f.write_str("PERFORMANCE_MARKER_INFO"),
8923            1000210003i32 => f.write_str("PERFORMANCE_STREAM_MARKER_INFO"),
8924            1000210004i32 => f.write_str("PERFORMANCE_OVERRIDE_INFO"),
8925            1000210005i32 => f.write_str("PERFORMANCE_CONFIGURATION_ACQUIRE_INFO"),
8926            1000212000i32 => f.write_str("PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES"),
8927            1000213000i32 => f.write_str("DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES"),
8928            1000213001i32 => f.write_str("SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO"),
8929            1000214000i32 => f.write_str("IMAGEPIPE_SURFACE_CREATE_INFO"),
8930            1000217000i32 => f.write_str("METAL_SURFACE_CREATE_INFO"),
8931            1000218000i32 => f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES"),
8932            1000218001i32 => {
8933                f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES")
8934            }
8935            1000218002i32 => f.write_str("RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO"),
8936            1000044007i32 => {
8937                f.write_str("RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO")
8938            }
8939            1000226000i32 => f.write_str("FRAGMENT_SHADING_RATE_ATTACHMENT_INFO"),
8940            1000226001i32 => {
8941                f.write_str("PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO")
8942            }
8943            1000226002i32 => {
8944                f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES")
8945            }
8946            1000226003i32 => {
8947                f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES")
8948            }
8949            1000226004i32 => f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE"),
8950            1000044006i32 => {
8951                f.write_str("RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO")
8952            }
8953            1000227000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2"),
8954            1000229000i32 => f.write_str("PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES"),
8955            1000231000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CONSTANT_DATA_FEATURES"),
8956            1000233000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ABORT_FEATURES"),
8957            1000233001i32 => f.write_str("DEVICE_FAULT_SHADER_ABORT_MESSAGE_INFO"),
8958            1000233002i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ABORT_PROPERTIES"),
8959            1000234000i32 => {
8960                f.write_str("PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES")
8961            }
8962            1000235000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES"),
8963            1000237000i32 => f.write_str("PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES"),
8964            1000238000i32 => f.write_str("PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES"),
8965            1000238001i32 => f.write_str("MEMORY_PRIORITY_ALLOCATE_INFO"),
8966            1000239000i32 => f.write_str("SURFACE_PROTECTED_CAPABILITIES"),
8967            1000240000i32 => {
8968                f.write_str(
8969                    "PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES",
8970                )
8971            }
8972            1000244002i32 => f.write_str("BUFFER_DEVICE_ADDRESS_CREATE_INFO"),
8973            1000247000i32 => f.write_str("VALIDATION_FEATURES"),
8974            1000248000i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES"),
8975            1000249000i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES"),
8976            1000249001i32 => f.write_str("COOPERATIVE_MATRIX_PROPERTIES"),
8977            1000249002i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES"),
8978            1000250000i32 => {
8979                f.write_str("PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES")
8980            }
8981            1000250001i32 => f.write_str("PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO"),
8982            1000250002i32 => f.write_str("FRAMEBUFFER_MIXED_SAMPLES_COMBINATION"),
8983            1000251000i32 => {
8984                f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES")
8985            }
8986            1000252000i32 => f.write_str("PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES"),
8987            1000254000i32 => f.write_str("PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES"),
8988            1000254001i32 => {
8989                f.write_str("PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO")
8990            }
8991            1000254002i32 => f.write_str("PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES"),
8992            1000255000i32 => f.write_str("SURFACE_FULL_SCREEN_EXCLUSIVE_INFO"),
8993            1000255002i32 => f.write_str("SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE"),
8994            1000255001i32 => f.write_str("SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO"),
8995            1000256000i32 => f.write_str("HEADLESS_SURFACE_CREATE_INFO"),
8996            1000260000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES"),
8997            1000267000i32 => {
8998                f.write_str("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES")
8999            }
9000            1000269000i32 => {
9001                f.write_str("PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES")
9002            }
9003            1000269001i32 => f.write_str("PIPELINE_INFO"),
9004            1000269002i32 => f.write_str("PIPELINE_EXECUTABLE_PROPERTIES"),
9005            1000269003i32 => f.write_str("PIPELINE_EXECUTABLE_INFO"),
9006            1000269004i32 => f.write_str("PIPELINE_EXECUTABLE_STATISTIC"),
9007            1000269005i32 => f.write_str("PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION"),
9008            1000272000i32 => f.write_str("PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES"),
9009            1000272001i32 => f.write_str("PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES"),
9010            1000272002i32 => f.write_str("MEMORY_MAP_PLACED_INFO"),
9011            1000273000i32 => {
9012                f.write_str("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES")
9013            }
9014            1000277000i32 => {
9015                f.write_str("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES")
9016            }
9017            1000277001i32 => f.write_str("GRAPHICS_SHADER_GROUP_CREATE_INFO"),
9018            1000277002i32 => f.write_str("GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO"),
9019            1000277003i32 => f.write_str("INDIRECT_COMMANDS_LAYOUT_TOKEN"),
9020            1000277004i32 => f.write_str("INDIRECT_COMMANDS_LAYOUT_CREATE_INFO"),
9021            1000277005i32 => f.write_str("GENERATED_COMMANDS_INFO"),
9022            1000277006i32 => f.write_str("GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO"),
9023            1000277007i32 => {
9024                f.write_str("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES")
9025            }
9026            1000278000i32 => {
9027                f.write_str("PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES")
9028            }
9029            1000278001i32 => {
9030                f.write_str("COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO")
9031            }
9032            1000281000i32 => {
9033                f.write_str("PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES")
9034            }
9035            1000282000i32 => {
9036                f.write_str("COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO")
9037            }
9038            1000282001i32 => f.write_str("RENDER_PASS_TRANSFORM_BEGIN_INFO"),
9039            1000283000i32 => f.write_str("PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES"),
9040            1000283001i32 => f.write_str("DEPTH_BIAS_INFO"),
9041            1000283002i32 => f.write_str("DEPTH_BIAS_REPRESENTATION_INFO"),
9042            1000284000i32 => f.write_str("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES"),
9043            1000284001i32 => f.write_str("DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO"),
9044            1000284002i32 => f.write_str("DEVICE_MEMORY_REPORT_CALLBACK_DATA"),
9045            1000287000i32 => f.write_str("SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO"),
9046            1000287001i32 => {
9047                f.write_str("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES")
9048            }
9049            1000287002i32 => f.write_str("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES"),
9050            1000288000i32 => {
9051                f.write_str("PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES")
9052            }
9053            1000290000i32 => f.write_str("PIPELINE_LIBRARY_CREATE_INFO"),
9054            1000292000i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES"),
9055            1000292001i32 => f.write_str("SURFACE_CAPABILITIES_PRESENT_BARRIER"),
9056            1000292002i32 => f.write_str("SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO"),
9057            1000294000i32 => f.write_str("PRESENT_ID"),
9058            1000294001i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_ID_FEATURES"),
9059            1000299000i32 => f.write_str("VIDEO_ENCODE_INFO"),
9060            1000299001i32 => f.write_str("VIDEO_ENCODE_RATE_CONTROL_INFO"),
9061            1000299002i32 => f.write_str("VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO"),
9062            1000299003i32 => f.write_str("VIDEO_ENCODE_CAPABILITIES"),
9063            1000299004i32 => f.write_str("VIDEO_ENCODE_USAGE_INFO"),
9064            1000299005i32 => f.write_str("QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO"),
9065            1000299006i32 => {
9066                f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO")
9067            }
9068            1000299007i32 => f.write_str("VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES"),
9069            1000299008i32 => f.write_str("VIDEO_ENCODE_QUALITY_LEVEL_INFO"),
9070            1000299009i32 => f.write_str("VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO"),
9071            1000299010i32 => f.write_str("VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO"),
9072            1000300000i32 => f.write_str("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES"),
9073            1000300001i32 => f.write_str("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO"),
9074            1000307000i32 => f.write_str("CUDA_MODULE_CREATE_INFO"),
9075            1000307001i32 => f.write_str("CUDA_FUNCTION_CREATE_INFO"),
9076            1000307002i32 => f.write_str("CUDA_LAUNCH_INFO"),
9077            1000307003i32 => f.write_str("PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES"),
9078            1000307004i32 => f.write_str("PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES"),
9079            1000309000i32 => f.write_str("PHYSICAL_DEVICE_TILE_SHADING_FEATURES"),
9080            1000309001i32 => f.write_str("PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES"),
9081            1000309002i32 => f.write_str("RENDER_PASS_TILE_SHADING_CREATE_INFO"),
9082            1000309003i32 => f.write_str("PER_TILE_BEGIN_INFO"),
9083            1000309004i32 => f.write_str("PER_TILE_END_INFO"),
9084            1000309005i32 => f.write_str("DISPATCH_TILE_INFO"),
9085            1000310000i32 => f.write_str("QUERY_LOW_LATENCY_SUPPORT"),
9086            1000311000i32 => f.write_str("EXPORT_METAL_OBJECT_CREATE_INFO"),
9087            1000311001i32 => f.write_str("EXPORT_METAL_OBJECTS_INFO"),
9088            1000311002i32 => f.write_str("EXPORT_METAL_DEVICE_INFO"),
9089            1000311003i32 => f.write_str("EXPORT_METAL_COMMAND_QUEUE_INFO"),
9090            1000311004i32 => f.write_str("EXPORT_METAL_BUFFER_INFO"),
9091            1000311005i32 => f.write_str("IMPORT_METAL_BUFFER_INFO"),
9092            1000311006i32 => f.write_str("EXPORT_METAL_TEXTURE_INFO"),
9093            1000311007i32 => f.write_str("IMPORT_METAL_TEXTURE_INFO"),
9094            1000311008i32 => f.write_str("EXPORT_METAL_IO_SURFACE_INFO"),
9095            1000311009i32 => f.write_str("IMPORT_METAL_IO_SURFACE_INFO"),
9096            1000311010i32 => f.write_str("EXPORT_METAL_SHARED_EVENT_INFO"),
9097            1000311011i32 => f.write_str("IMPORT_METAL_SHARED_EVENT_INFO"),
9098            1000316000i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES"),
9099            1000316001i32 => {
9100                f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES")
9101            }
9102            1000316002i32 => f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES"),
9103            1000316003i32 => f.write_str("DESCRIPTOR_ADDRESS_INFO"),
9104            1000316004i32 => f.write_str("DESCRIPTOR_GET_INFO"),
9105            1000316005i32 => f.write_str("BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO"),
9106            1000316006i32 => f.write_str("IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO"),
9107            1000316007i32 => f.write_str("IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO"),
9108            1000316008i32 => f.write_str("SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO"),
9109            1000316010i32 => f.write_str("OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO"),
9110            1000316011i32 => f.write_str("DESCRIPTOR_BUFFER_BINDING_INFO"),
9111            1000316012i32 => {
9112                f.write_str("DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE")
9113            }
9114            1000316009i32 => {
9115                f.write_str("ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO")
9116            }
9117            1000318000i32 => f.write_str("DEVICE_MEMORY_COPY"),
9118            1000318001i32 => f.write_str("COPY_DEVICE_MEMORY_INFO"),
9119            1000318002i32 => f.write_str("DEVICE_MEMORY_IMAGE_COPY"),
9120            1000318003i32 => f.write_str("COPY_DEVICE_MEMORY_IMAGE_INFO"),
9121            1000318004i32 => f.write_str("MEMORY_RANGE_BARRIERS_INFO"),
9122            1000318005i32 => f.write_str("MEMORY_RANGE_BARRIER"),
9123            1000318006i32 => {
9124                f.write_str("PHYSICAL_DEVICE_DEVICE_ADDRESS_COMMANDS_FEATURES")
9125            }
9126            1000318007i32 => f.write_str("BIND_INDEX_BUFFER_3_INFO"),
9127            1000318008i32 => f.write_str("BIND_VERTEX_BUFFER_3_INFO"),
9128            1000318009i32 => f.write_str("DRAW_INDIRECT_2_INFO"),
9129            1000318010i32 => f.write_str("DRAW_INDIRECT_COUNT_2_INFO"),
9130            1000318011i32 => f.write_str("DISPATCH_INDIRECT_2_INFO"),
9131            1000318012i32 => f.write_str("CONDITIONAL_RENDERING_BEGIN_INFO_2"),
9132            1000318013i32 => f.write_str("BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO"),
9133            1000318014i32 => f.write_str("MEMORY_MARKER_INFO"),
9134            1000318015i32 => f.write_str("ACCELERATION_STRUCTURE_CREATE_INFO_2"),
9135            1000320000i32 => {
9136                f.write_str("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES")
9137            }
9138            1000320001i32 => {
9139                f.write_str("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES")
9140            }
9141            1000320002i32 => f.write_str("GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO"),
9142            1000321000i32 => {
9143                f.write_str(
9144                    "PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES",
9145                )
9146            }
9147            1000322000i32 => {
9148                f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES")
9149            }
9150            1000323000i32 => {
9151                f.write_str(
9152                    "PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES",
9153                )
9154            }
9155            1000326000i32 => {
9156                f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES")
9157            }
9158            1000326001i32 => {
9159                f.write_str("PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES")
9160            }
9161            1000326002i32 => {
9162                f.write_str("PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO")
9163            }
9164            1000327000i32 => {
9165                f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA")
9166            }
9167            1000327001i32 => {
9168                f.write_str("PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES")
9169            }
9170            1000327002i32 => f.write_str("ACCELERATION_STRUCTURE_MOTION_INFO"),
9171            1000330000i32 => {
9172                f.write_str("PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES")
9173            }
9174            1000332000i32 => {
9175                f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES")
9176            }
9177            1000332001i32 => {
9178                f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES")
9179            }
9180            1000333000i32 => f.write_str("COPY_COMMAND_TRANSFORM_INFO"),
9181            1000336000i32 => {
9182                f.write_str("PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES")
9183            }
9184            1000338000i32 => {
9185                f.write_str("PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES")
9186            }
9187            1000338001i32 => f.write_str("IMAGE_COMPRESSION_CONTROL"),
9188            1000338004i32 => f.write_str("IMAGE_COMPRESSION_PROPERTIES"),
9189            1000339000i32 => {
9190                f.write_str("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES")
9191            }
9192            1000340000i32 => f.write_str("PHYSICAL_DEVICE_4444_FORMATS_FEATURES"),
9193            1000341000i32 => f.write_str("PHYSICAL_DEVICE_FAULT_FEATURES"),
9194            1000341001i32 => f.write_str("DEVICE_FAULT_COUNTS"),
9195            1000341002i32 => f.write_str("DEVICE_FAULT_INFO"),
9196            1000344000i32 => f.write_str("PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES"),
9197            1000346000i32 => f.write_str("DIRECTFB_SURFACE_CREATE_INFO"),
9198            1000352000i32 => {
9199                f.write_str("PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES")
9200            }
9201            1000352001i32 => f.write_str("VERTEX_INPUT_BINDING_DESCRIPTION_2"),
9202            1000352002i32 => f.write_str("VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2"),
9203            1000353000i32 => f.write_str("PHYSICAL_DEVICE_DRM_PROPERTIES"),
9204            1000354000i32 => {
9205                f.write_str("PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES")
9206            }
9207            1000354001i32 => f.write_str("DEVICE_ADDRESS_BINDING_CALLBACK_DATA"),
9208            1000355000i32 => f.write_str("PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES"),
9209            1000355001i32 => {
9210                f.write_str("PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO")
9211            }
9212            1000356000i32 => {
9213                f.write_str("PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES")
9214            }
9215            1000364000i32 => f.write_str("IMPORT_MEMORY_ZIRCON_HANDLE_INFO"),
9216            1000364001i32 => f.write_str("MEMORY_ZIRCON_HANDLE_PROPERTIES"),
9217            1000364002i32 => f.write_str("MEMORY_GET_ZIRCON_HANDLE_INFO"),
9218            1000365000i32 => f.write_str("IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO"),
9219            1000365001i32 => f.write_str("SEMAPHORE_GET_ZIRCON_HANDLE_INFO"),
9220            1000366000i32 => f.write_str("BUFFER_COLLECTION_CREATE_INFO"),
9221            1000366001i32 => f.write_str("IMPORT_MEMORY_BUFFER_COLLECTION"),
9222            1000366002i32 => f.write_str("BUFFER_COLLECTION_IMAGE_CREATE_INFO"),
9223            1000366003i32 => f.write_str("BUFFER_COLLECTION_PROPERTIES"),
9224            1000366004i32 => f.write_str("BUFFER_CONSTRAINTS_INFO"),
9225            1000366005i32 => f.write_str("BUFFER_COLLECTION_BUFFER_CREATE_INFO"),
9226            1000366006i32 => f.write_str("IMAGE_CONSTRAINTS_INFO"),
9227            1000366007i32 => f.write_str("IMAGE_FORMAT_CONSTRAINTS_INFO"),
9228            1000366008i32 => f.write_str("SYSMEM_COLOR_SPACE"),
9229            1000366009i32 => f.write_str("BUFFER_COLLECTION_CONSTRAINTS_INFO"),
9230            1000369000i32 => f.write_str("SUBPASS_SHADING_PIPELINE_CREATE_INFO"),
9231            1000369001i32 => f.write_str("PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES"),
9232            1000369002i32 => f.write_str("PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES"),
9233            1000370000i32 => f.write_str("PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES"),
9234            1000371000i32 => f.write_str("MEMORY_GET_REMOTE_ADDRESS_INFO"),
9235            1000371001i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES"),
9236            1000372000i32 => f.write_str("PIPELINE_PROPERTIES_IDENTIFIER"),
9237            1000372001i32 => f.write_str("PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES"),
9238            1000375000i32 => f.write_str("PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES"),
9239            1000375001i32 => f.write_str("FRAME_BOUNDARY"),
9240            1000376000i32 => {
9241                f.write_str(
9242                    "PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES",
9243                )
9244            }
9245            1000376001i32 => f.write_str("SUBPASS_RESOLVE_PERFORMANCE_QUERY"),
9246            1000376002i32 => f.write_str("MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO"),
9247            1000377000i32 => {
9248                f.write_str("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES")
9249            }
9250            1000378000i32 => f.write_str("SCREEN_SURFACE_CREATE_INFO"),
9251            1000381000i32 => f.write_str("PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES"),
9252            1000381001i32 => f.write_str("PIPELINE_COLOR_WRITE_CREATE_INFO"),
9253            1000382000i32 => {
9254                f.write_str("PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES")
9255            }
9256            1000386000i32 => {
9257                f.write_str("PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES")
9258            }
9259            1000387000i32 => {
9260                f.write_str("PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES")
9261            }
9262            1000390000i32 => {
9263                f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES")
9264            }
9265            1000390001i32 => f.write_str("VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES"),
9266            1000390002i32 => f.write_str("VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO"),
9267            1000390003i32 => {
9268                f.write_str("VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO")
9269            }
9270            1000391000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES"),
9271            1000391001i32 => f.write_str("IMAGE_VIEW_MIN_LOD_CREATE_INFO"),
9272            1000392000i32 => f.write_str("PHYSICAL_DEVICE_MULTI_DRAW_FEATURES"),
9273            1000392001i32 => f.write_str("PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES"),
9274            1000393000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES"),
9275            1000395000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES"),
9276            1000395001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES"),
9277            1000396000i32 => f.write_str("MICROMAP_BUILD_INFO"),
9278            1000396001i32 => f.write_str("MICROMAP_VERSION_INFO"),
9279            1000396002i32 => f.write_str("COPY_MICROMAP_INFO"),
9280            1000396003i32 => f.write_str("COPY_MICROMAP_TO_MEMORY_INFO"),
9281            1000396004i32 => f.write_str("COPY_MEMORY_TO_MICROMAP_INFO"),
9282            1000396005i32 => f.write_str("PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES"),
9283            1000396006i32 => f.write_str("PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES"),
9284            1000396007i32 => f.write_str("MICROMAP_CREATE_INFO"),
9285            1000396008i32 => f.write_str("MICROMAP_BUILD_SIZES_INFO"),
9286            1000396009i32 => {
9287                f.write_str("ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP")
9288            }
9289            1000397000i32 => {
9290                f.write_str("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES")
9291            }
9292            1000397001i32 => {
9293                f.write_str("PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES")
9294            }
9295            1000397002i32 => {
9296                f.write_str("ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP")
9297            }
9298            1000404000i32 => {
9299                f.write_str("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES")
9300            }
9301            1000404001i32 => {
9302                f.write_str("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES")
9303            }
9304            1000404002i32 => {
9305                f.write_str("PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES")
9306            }
9307            1000411000i32 => f.write_str("PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES"),
9308            1000411001i32 => {
9309                f.write_str("SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO")
9310            }
9311            1000412000i32 => {
9312                f.write_str("PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES")
9313            }
9314            1000417000i32 => f.write_str("DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO"),
9315            1000417001i32 => f.write_str("PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES"),
9316            1000417002i32 => {
9317                f.write_str("PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES")
9318            }
9319            1000418000i32 => {
9320                f.write_str("PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES")
9321            }
9322            1000418001i32 => f.write_str("IMAGE_VIEW_SLICED_CREATE_INFO"),
9323            1000420000i32 => {
9324                f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES")
9325            }
9326            1000420001i32 => f.write_str("DESCRIPTOR_SET_BINDING_REFERENCE"),
9327            1000420002i32 => f.write_str("DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO"),
9328            1000422000i32 => {
9329                f.write_str("PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES")
9330            }
9331            1000424000i32 => f.write_str("PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES"),
9332            1000424001i32 => {
9333                f.write_str("PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES")
9334            }
9335            1000424002i32 => f.write_str("RENDER_PASS_STRIPE_BEGIN_INFO"),
9336            1000424003i32 => f.write_str("RENDER_PASS_STRIPE_INFO"),
9337            1000424004i32 => f.write_str("RENDER_PASS_STRIPE_SUBMIT_INFO"),
9338            1000426000i32 => f.write_str("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES"),
9339            1000428000i32 => {
9340                f.write_str("PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES")
9341            }
9342            1000428001i32 => f.write_str("COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO"),
9343            1000428002i32 => f.write_str("PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO"),
9344            1000429008i32 => {
9345                f.write_str("PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES")
9346            }
9347            1000429009i32 => {
9348                f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA")
9349            }
9350            1000429010i32 => f.write_str("ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA"),
9351            1000430000i32 => {
9352                f.write_str("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES")
9353            }
9354            1000434000i32 => {
9355                f.write_str("PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES")
9356            }
9357            1000437000i32 => {
9358                f.write_str(
9359                    "PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES",
9360                )
9361            }
9362            1000440000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES"),
9363            1000440001i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES"),
9364            1000440002i32 => f.write_str("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO"),
9365            1000451000i32 => {
9366                f.write_str("PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES")
9367            }
9368            1000451001i32 => {
9369                f.write_str("PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES")
9370            }
9371            1000452000i32 => f.write_str("NATIVE_BUFFER_USAGE"),
9372            1000452001i32 => f.write_str("NATIVE_BUFFER_PROPERTIES"),
9373            1000452002i32 => f.write_str("NATIVE_BUFFER_FORMAT_PROPERTIES"),
9374            1000452003i32 => f.write_str("IMPORT_NATIVE_BUFFER_INFO"),
9375            1000452004i32 => f.write_str("MEMORY_GET_NATIVE_BUFFER_INFO"),
9376            1000453000i32 => f.write_str("EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED"),
9377            1000455000i32 => {
9378                f.write_str("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES")
9379            }
9380            1000455001i32 => {
9381                f.write_str("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES")
9382            }
9383            1000458000i32 => {
9384                f.write_str("PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES")
9385            }
9386            1000458001i32 => f.write_str("RENDER_PASS_CREATION_CONTROL"),
9387            1000458002i32 => f.write_str("RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO"),
9388            1000458003i32 => f.write_str("RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO"),
9389            1000459000i32 => f.write_str("DIRECT_DRIVER_LOADING_INFO"),
9390            1000459001i32 => f.write_str("DIRECT_DRIVER_LOADING_LIST"),
9391            1000460000i32 => f.write_str("TENSOR_CREATE_INFO"),
9392            1000460001i32 => f.write_str("TENSOR_VIEW_CREATE_INFO"),
9393            1000460002i32 => f.write_str("BIND_TENSOR_MEMORY_INFO"),
9394            1000460003i32 => f.write_str("WRITE_DESCRIPTOR_SET_TENSOR"),
9395            1000460004i32 => f.write_str("PHYSICAL_DEVICE_TENSOR_PROPERTIES"),
9396            1000460005i32 => f.write_str("TENSOR_FORMAT_PROPERTIES"),
9397            1000460006i32 => f.write_str("TENSOR_DESCRIPTION"),
9398            1000460007i32 => f.write_str("TENSOR_MEMORY_REQUIREMENTS_INFO"),
9399            1000460008i32 => f.write_str("TENSOR_MEMORY_BARRIER"),
9400            1000460009i32 => f.write_str("PHYSICAL_DEVICE_TENSOR_FEATURES"),
9401            1000460010i32 => f.write_str("DEVICE_TENSOR_MEMORY_REQUIREMENTS"),
9402            1000460011i32 => f.write_str("COPY_TENSOR_INFO"),
9403            1000460012i32 => f.write_str("TENSOR_COPY"),
9404            1000460013i32 => f.write_str("TENSOR_DEPENDENCY_INFO"),
9405            1000460014i32 => f.write_str("MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR"),
9406            1000460015i32 => f.write_str("PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO"),
9407            1000460016i32 => f.write_str("EXTERNAL_TENSOR_PROPERTIES"),
9408            1000460017i32 => f.write_str("EXTERNAL_MEMORY_TENSOR_CREATE_INFO"),
9409            1000460018i32 => {
9410                f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES")
9411            }
9412            1000460019i32 => {
9413                f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES")
9414            }
9415            1000460020i32 => f.write_str("DESCRIPTOR_GET_TENSOR_INFO"),
9416            1000460021i32 => f.write_str("TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO"),
9417            1000460022i32 => f.write_str("TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO"),
9418            1000460023i32 => f.write_str("FRAME_BOUNDARY_TENSORS"),
9419            1000462000i32 => {
9420                f.write_str("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES")
9421            }
9422            1000462001i32 => {
9423                f.write_str("PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES")
9424            }
9425            1000462002i32 => {
9426                f.write_str("PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO")
9427            }
9428            1000462003i32 => f.write_str("SHADER_MODULE_IDENTIFIER"),
9429            1000464000i32 => f.write_str("PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES"),
9430            1000464001i32 => f.write_str("PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES"),
9431            1000464002i32 => f.write_str("OPTICAL_FLOW_IMAGE_FORMAT_INFO"),
9432            1000464003i32 => f.write_str("OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES"),
9433            1000464004i32 => f.write_str("OPTICAL_FLOW_SESSION_CREATE_INFO"),
9434            1000464005i32 => f.write_str("OPTICAL_FLOW_EXECUTE_INFO"),
9435            1000464010i32 => f.write_str("OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO"),
9436            1000465000i32 => f.write_str("PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES"),
9437            1000468000i32 => {
9438                f.write_str("PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES")
9439            }
9440            1000468001i32 => {
9441                f.write_str("PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES")
9442            }
9443            1000468002i32 => {
9444                f.write_str("ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES")
9445            }
9446            1000476000i32 => f.write_str("PHYSICAL_DEVICE_ANTI_LAG_FEATURES"),
9447            1000476001i32 => f.write_str("ANTI_LAG_DATA"),
9448            1000476002i32 => f.write_str("ANTI_LAG_PRESENTATION_INFO"),
9449            1000478000i32 => {
9450                f.write_str("PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES")
9451            }
9452            1000478001i32 => {
9453                f.write_str(
9454                    "ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA",
9455                )
9456            }
9457            1000479000i32 => f.write_str("SURFACE_CAPABILITIES_PRESENT_ID_2"),
9458            1000479001i32 => f.write_str("PRESENT_ID_2"),
9459            1000479002i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES"),
9460            1000480000i32 => f.write_str("SURFACE_CAPABILITIES_PRESENT_WAIT_2"),
9461            1000480001i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES"),
9462            1000480002i32 => f.write_str("PRESENT_WAIT_2_INFO"),
9463            1000481000i32 => {
9464                f.write_str("PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES")
9465            }
9466            1000482000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES"),
9467            1000482001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES"),
9468            1000482002i32 => f.write_str("SHADER_CREATE_INFO"),
9469            1000483000i32 => f.write_str("PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES"),
9470            1000483001i32 => f.write_str("PIPELINE_BINARY_CREATE_INFO"),
9471            1000483002i32 => f.write_str("PIPELINE_BINARY_INFO"),
9472            1000483003i32 => f.write_str("PIPELINE_BINARY_KEY"),
9473            1000483004i32 => f.write_str("PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES"),
9474            1000483005i32 => f.write_str("RELEASE_CAPTURED_PIPELINE_DATA_INFO"),
9475            1000483006i32 => f.write_str("PIPELINE_BINARY_DATA_INFO"),
9476            1000483007i32 => f.write_str("PIPELINE_CREATE_INFO"),
9477            1000483008i32 => f.write_str("DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL"),
9478            1000483009i32 => f.write_str("PIPELINE_BINARY_HANDLES_INFO"),
9479            1000484000i32 => f.write_str("PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES"),
9480            1000484001i32 => f.write_str("TILE_PROPERTIES"),
9481            1000485000i32 => f.write_str("PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES"),
9482            1000485001i32 => f.write_str("AMIGO_PROFILING_SUBMIT_INFO"),
9483            1000488000i32 => {
9484                f.write_str("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES")
9485            }
9486            1000490000i32 => {
9487                f.write_str("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES")
9488            }
9489            1000490001i32 => {
9490                f.write_str("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES")
9491            }
9492            1000491000i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES"),
9493            1000491001i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES"),
9494            1000491002i32 => f.write_str("COOPERATIVE_VECTOR_PROPERTIES"),
9495            1000491004i32 => f.write_str("CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO"),
9496            1000492000i32 => {
9497                f.write_str("PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES")
9498            }
9499            1000492001i32 => {
9500                f.write_str("PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES")
9501            }
9502            1000495000i32 => {
9503                f.write_str("PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES")
9504            }
9505            1000495001i32 => {
9506                f.write_str("PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES")
9507            }
9508            1000496000i32 => f.write_str("LAYER_SETTINGS_CREATE_INFO"),
9509            1000497000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES"),
9510            1000497001i32 => {
9511                f.write_str("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES")
9512            }
9513            1000498000i32 => {
9514                f.write_str("PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES")
9515            }
9516            1000499000i32 => {
9517                f.write_str(
9518                    "PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES",
9519                )
9520            }
9521            1000504000i32 => {
9522                f.write_str("PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES")
9523            }
9524            1000505000i32 => f.write_str("LATENCY_SLEEP_MODE_INFO"),
9525            1000505001i32 => f.write_str("LATENCY_SLEEP_INFO"),
9526            1000505002i32 => f.write_str("SET_LATENCY_MARKER_INFO"),
9527            1000505003i32 => f.write_str("GET_LATENCY_MARKER_INFO"),
9528            1000505004i32 => f.write_str("LATENCY_TIMINGS_FRAME_REPORT"),
9529            1000505005i32 => f.write_str("LATENCY_SUBMISSION_PRESENT_ID"),
9530            1000505006i32 => f.write_str("OUT_OF_BAND_QUEUE_TYPE_INFO"),
9531            1000505007i32 => f.write_str("SWAPCHAIN_LATENCY_CREATE_INFO"),
9532            1000505008i32 => f.write_str("LATENCY_SURFACE_CAPABILITIES"),
9533            1000507000i32 => f.write_str("DATA_GRAPH_PIPELINE_CREATE_INFO"),
9534            1000507001i32 => f.write_str("DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO"),
9535            1000507002i32 => f.write_str("DATA_GRAPH_PIPELINE_RESOURCE_INFO"),
9536            1000507003i32 => f.write_str("DATA_GRAPH_PIPELINE_CONSTANT"),
9537            1000507004i32 => {
9538                f.write_str("DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO")
9539            }
9540            1000507005i32 => f.write_str("BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO"),
9541            1000507006i32 => f.write_str("PHYSICAL_DEVICE_DATA_GRAPH_FEATURES"),
9542            1000507007i32 => f.write_str("DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO"),
9543            1000507008i32 => f.write_str("DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT"),
9544            1000507009i32 => f.write_str("DATA_GRAPH_PIPELINE_INFO"),
9545            1000507010i32 => {
9546                f.write_str("DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO")
9547            }
9548            1000507011i32 => {
9549                f.write_str("DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO")
9550            }
9551            1000507012i32 => {
9552                f.write_str("DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT")
9553            }
9554            1000507013i32 => f.write_str("DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO"),
9555            1000507014i32 => f.write_str("DATA_GRAPH_PIPELINE_DISPATCH_INFO"),
9556            1000507016i32 => f.write_str("DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO"),
9557            1000507017i32 => {
9558                f.write_str("QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES")
9559            }
9560            1000507018i32 => f.write_str("QUEUE_FAMILY_DATA_GRAPH_PROPERTIES"),
9561            1000507019i32 => {
9562                f.write_str(
9563                    "PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO",
9564                )
9565            }
9566            1000507015i32 => {
9567                f.write_str(
9568                    "DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO",
9569                )
9570            }
9571            1000510000i32 => {
9572                f.write_str("PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES")
9573            }
9574            1000510001i32 => {
9575                f.write_str("MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO")
9576            }
9577            1000511000i32 => {
9578                f.write_str("PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES")
9579            }
9580            1000512000i32 => f.write_str("VIDEO_DECODE_AV1_CAPABILITIES"),
9581            1000512001i32 => f.write_str("VIDEO_DECODE_AV1_PICTURE_INFO"),
9582            1000512003i32 => f.write_str("VIDEO_DECODE_AV1_PROFILE_INFO"),
9583            1000512004i32 => {
9584                f.write_str("VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO")
9585            }
9586            1000512005i32 => f.write_str("VIDEO_DECODE_AV1_DPB_SLOT_INFO"),
9587            1000513000i32 => f.write_str("VIDEO_ENCODE_AV1_CAPABILITIES"),
9588            1000513001i32 => {
9589                f.write_str("VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO")
9590            }
9591            1000513002i32 => f.write_str("VIDEO_ENCODE_AV1_PICTURE_INFO"),
9592            1000513003i32 => f.write_str("VIDEO_ENCODE_AV1_DPB_SLOT_INFO"),
9593            1000513004i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES"),
9594            1000513005i32 => f.write_str("VIDEO_ENCODE_AV1_PROFILE_INFO"),
9595            1000513006i32 => f.write_str("VIDEO_ENCODE_AV1_RATE_CONTROL_INFO"),
9596            1000513007i32 => f.write_str("VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO"),
9597            1000513008i32 => f.write_str("VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES"),
9598            1000513009i32 => f.write_str("VIDEO_ENCODE_AV1_SESSION_CREATE_INFO"),
9599            1000513010i32 => f.write_str("VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO"),
9600            1000514000i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES"),
9601            1000514001i32 => f.write_str("VIDEO_DECODE_VP9_CAPABILITIES"),
9602            1000514002i32 => f.write_str("VIDEO_DECODE_VP9_PICTURE_INFO"),
9603            1000514003i32 => f.write_str("VIDEO_DECODE_VP9_PROFILE_INFO"),
9604            1000515000i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES"),
9605            1000515001i32 => f.write_str("VIDEO_INLINE_QUERY_INFO"),
9606            1000516000i32 => {
9607                f.write_str("PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES")
9608            }
9609            1000518000i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES"),
9610            1000518001i32 => f.write_str("PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES"),
9611            1000518002i32 => f.write_str("SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO"),
9612            1000519000i32 => f.write_str("SAMPLER_CUBIC_WEIGHTS_CREATE_INFO"),
9613            1000519001i32 => f.write_str("PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES"),
9614            1000519002i32 => f.write_str("BLIT_IMAGE_CUBIC_WEIGHTS_INFO"),
9615            1000520000i32 => f.write_str("PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES"),
9616            1000520001i32 => {
9617                f.write_str("SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO")
9618            }
9619            1000521000i32 => f.write_str("PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES"),
9620            1000524000i32 => {
9621                f.write_str(
9622                    "PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES",
9623                )
9624            }
9625            1000527000i32 => {
9626                f.write_str("PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES")
9627            }
9628            1000527001i32 => f.write_str("ATTACHMENT_FEEDBACK_LOOP_INFO"),
9629            1000529000i32 => f.write_str("SCREEN_BUFFER_PROPERTIES"),
9630            1000529001i32 => f.write_str("SCREEN_BUFFER_FORMAT_PROPERTIES"),
9631            1000529002i32 => f.write_str("IMPORT_SCREEN_BUFFER_INFO"),
9632            1000529004i32 => {
9633                f.write_str("PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES")
9634            }
9635            1000530000i32 => f.write_str("PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES"),
9636            1000545007i32 => f.write_str("SET_DESCRIPTOR_BUFFER_OFFSETS_INFO"),
9637            1000545008i32 => f.write_str("BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO"),
9638            1000546000i32 => {
9639                f.write_str("PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES")
9640            }
9641            1000547000i32 => f.write_str("PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES"),
9642            1000547001i32 => f.write_str("PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES"),
9643            1000547002i32 => f.write_str("TILE_MEMORY_REQUIREMENTS"),
9644            1000547003i32 => f.write_str("TILE_MEMORY_BIND_INFO"),
9645            1000547004i32 => f.write_str("TILE_MEMORY_SIZE_INFO"),
9646            1000549002i32 => f.write_str("COPY_MEMORY_INDIRECT_INFO"),
9647            1000549003i32 => f.write_str("COPY_MEMORY_TO_IMAGE_INDIRECT_INFO"),
9648            1000550002i32 => f.write_str("DECOMPRESS_MEMORY_INFO"),
9649            1000551000i32 => f.write_str("DISPLAY_SURFACE_STEREO_CREATE_INFO"),
9650            1000551001i32 => f.write_str("DISPLAY_MODE_STEREO_PROPERTIES"),
9651            1000552000i32 => f.write_str("VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES"),
9652            1000552001i32 => {
9653                f.write_str("VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO")
9654            }
9655            1000552002i32 => f.write_str("VIDEO_ENCODE_INTRA_REFRESH_INFO"),
9656            1000552003i32 => f.write_str("VIDEO_REFERENCE_INTRA_REFRESH_INFO"),
9657            1000552004i32 => {
9658                f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES")
9659            }
9660            1000553000i32 => f.write_str("VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES"),
9661            1000553001i32 => f.write_str("VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES"),
9662            1000553002i32 => f.write_str("VIDEO_ENCODE_QUANTIZATION_MAP_INFO"),
9663            1000553005i32 => {
9664                f.write_str(
9665                    "VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO",
9666                )
9667            }
9668            1000553009i32 => {
9669                f.write_str("PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES")
9670            }
9671            1000553003i32 => {
9672                f.write_str("VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES")
9673            }
9674            1000553004i32 => {
9675                f.write_str("VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES")
9676            }
9677            1000553006i32 => f.write_str("VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES"),
9678            1000553007i32 => {
9679                f.write_str("VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES")
9680            }
9681            1000553008i32 => f.write_str("VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES"),
9682            1000555000i32 => f.write_str("PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES"),
9683            1000556000i32 => f.write_str("EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO"),
9684            1000556001i32 => f.write_str("EXTERNAL_COMPUTE_QUEUE_CREATE_INFO"),
9685            1000556002i32 => f.write_str("EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS"),
9686            1000556003i32 => {
9687                f.write_str("PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES")
9688            }
9689            1000558000i32 => {
9690                f.write_str(
9691                    "PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES",
9692                )
9693            }
9694            1000559000i32 => {
9695                f.write_str("PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES")
9696            }
9697            1000562000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES"),
9698            1000562001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES"),
9699            1000562002i32 => f.write_str("PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST"),
9700            1000562003i32 => f.write_str("PHYSICAL_DEVICE_LAYERED_API_PROPERTIES"),
9701            1000562004i32 => f.write_str("PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES"),
9702            1000563000i32 => {
9703                f.write_str("PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES")
9704            }
9705            1000564000i32 => {
9706                f.write_str("PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES")
9707            }
9708            1000567000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES"),
9709            1000568000i32 => {
9710                f.write_str("PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES")
9711            }
9712            1000569000i32 => {
9713                f.write_str("PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES")
9714            }
9715            1000569001i32 => {
9716                f.write_str("PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES")
9717            }
9718            1000569002i32 => {
9719                f.write_str("CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT")
9720            }
9721            1000569003i32 => {
9722                f.write_str("CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT")
9723            }
9724            1000569004i32 => {
9725                f.write_str("CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT")
9726            }
9727            1000569005i32 => f.write_str("CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO"),
9728            1000569006i32 => f.write_str("CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO"),
9729            1000569007i32 => {
9730                f.write_str(
9731                    "RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO",
9732                )
9733            }
9734            1000570000i32 => {
9735                f.write_str(
9736                    "PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES",
9737                )
9738            }
9739            1000570001i32 => {
9740                f.write_str(
9741                    "PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES",
9742                )
9743            }
9744            1000570002i32 => {
9745                f.write_str("WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE")
9746            }
9747            1000570003i32 => {
9748                f.write_str("PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT")
9749            }
9750            1000570004i32 => f.write_str("BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO"),
9751            1000570005i32 => f.write_str("PARTITIONED_ACCELERATION_STRUCTURE_FLAGS"),
9752            1000572003i32 => f.write_str("INDIRECT_EXECUTION_SET_CREATE_INFO"),
9753            1000572008i32 => f.write_str("WRITE_INDIRECT_EXECUTION_SET_PIPELINE"),
9754            1000572009i32 => f.write_str("WRITE_INDIRECT_EXECUTION_SET_SHADER"),
9755            1000572010i32 => f.write_str("INDIRECT_EXECUTION_SET_PIPELINE_INFO"),
9756            1000572011i32 => f.write_str("INDIRECT_EXECUTION_SET_SHADER_INFO"),
9757            1000572012i32 => f.write_str("INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO"),
9758            1000572013i32 => f.write_str("GENERATED_COMMANDS_PIPELINE_INFO"),
9759            1000572014i32 => f.write_str("GENERATED_COMMANDS_SHADER_INFO"),
9760            1000573001i32 => f.write_str("PHYSICAL_DEVICE_FAULT_PROPERTIES"),
9761            1000573003i32 => f.write_str("DEVICE_FAULT_DEBUG_INFO"),
9762            1000574000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES"),
9763            1000574002i32 => f.write_str("MEMORY_BARRIER_ACCESS_FLAGS_3"),
9764            1000575000i32 => {
9765                f.write_str("PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES")
9766            }
9767            1000575001i32 => {
9768                f.write_str("PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES")
9769            }
9770            1000575002i32 => f.write_str("IMAGE_ALIGNMENT_CONTROL_CREATE_INFO"),
9771            1000579000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_FMA_FEATURES"),
9772            1000580000i32 => f.write_str("PUSH_CONSTANT_BANK_INFO"),
9773            1000580001i32 => f.write_str("PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES"),
9774            1000580002i32 => f.write_str("PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES"),
9775            1000582000i32 => f.write_str("PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES"),
9776            1000582001i32 => {
9777                f.write_str("PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO")
9778            }
9779            1000584000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES"),
9780            1000584001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES"),
9781            1000584002i32 => f.write_str("QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES"),
9782            1000586000i32 => f.write_str("PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES"),
9783            1000586001i32 => {
9784                f.write_str("VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO")
9785            }
9786            1000586002i32 => {
9787                f.write_str("VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO")
9788            }
9789            1000586003i32 => {
9790                f.write_str("VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO")
9791            }
9792            1000685000i32 => f.write_str("SURFACE_CREATE_INFO"),
9793            1000590000i32 => f.write_str("PHYSICAL_DEVICE_HDR_VIVID_FEATURES"),
9794            1000590001i32 => f.write_str("HDR_VIVID_DYNAMIC_METADATA"),
9795            1000593000i32 => f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES"),
9796            1000593001i32 => {
9797                f.write_str("COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES")
9798            }
9799            1000593002i32 => {
9800                f.write_str("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES")
9801            }
9802            1000596000i32 => {
9803                f.write_str("PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES")
9804            }
9805            1000602000i32 => f.write_str("IMPORT_MEMORY_METAL_HANDLE_INFO"),
9806            1000602001i32 => f.write_str("MEMORY_METAL_HANDLE_PROPERTIES"),
9807            1000602002i32 => f.write_str("MEMORY_GET_METAL_HANDLE_INFO"),
9808            1000605000i32 => {
9809                f.write_str("PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES")
9810            }
9811            1000605001i32 => {
9812                f.write_str("PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES")
9813            }
9814            1000605004i32 => {
9815                f.write_str("RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO")
9816            }
9817            1000607000i32 => {
9818                f.write_str("PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_FEATURES")
9819            }
9820            1000607001i32 => {
9821                f.write_str("PHYSICAL_DEVICE_SHADER_INSTRUMENTATION_PROPERTIES")
9822            }
9823            1000607002i32 => f.write_str("SHADER_INSTRUMENTATION_CREATE_INFO"),
9824            1000607003i32 => f.write_str("SHADER_INSTRUMENTATION_METRIC_DESCRIPTION"),
9825            1000608000i32 => {
9826                f.write_str("PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES")
9827            }
9828            1000609000i32 => f.write_str("PHYSICAL_DEVICE_FORMAT_PACK_FEATURES"),
9829            1000611000i32 => {
9830                f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES")
9831            }
9832            1000611001i32 => {
9833                f.write_str("PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES")
9834            }
9835            1000611002i32 => {
9836                f.write_str("PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO")
9837            }
9838            1000613000i32 => f.write_str("SET_PRESENT_CONFIG"),
9839            1000613001i32 => f.write_str("PHYSICAL_DEVICE_PRESENT_METERING_FEATURES"),
9840            1000425002i32 => {
9841                f.write_str("RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO")
9842            }
9843            1000620000i32 => {
9844                f.write_str("PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES")
9845            }
9846            1000627000i32 => {
9847                f.write_str("PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES")
9848            }
9849            1000628000i32 => f.write_str("PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES"),
9850            1000628001i32 => f.write_str("BEGIN_CUSTOM_RESOLVE_INFO"),
9851            1000628002i32 => f.write_str("CUSTOM_RESOLVE_CREATE_INFO"),
9852            1000629000i32 => f.write_str("PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES"),
9853            1000629001i32 => f.write_str("DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO"),
9854            1000630000i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES"),
9855            1000630001i32 => f.write_str("PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES"),
9856            1000630002i32 => f.write_str("RENDERING_ATTACHMENT_FLAGS_INFO"),
9857            1000630004i32 => f.write_str("RESOLVE_IMAGE_MODE_INFO"),
9858            1000635000i32 => f.write_str("PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES"),
9859            1000635001i32 => f.write_str("PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES"),
9860            1000637000i32 => {
9861                f.write_str("PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES")
9862            }
9863            1000642000i32 => {
9864                f.write_str(
9865                    "PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES",
9866                )
9867            }
9868            1000645000i32 => f.write_str("COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS"),
9869            1000645001i32 => {
9870                f.write_str("PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES")
9871            }
9872            1000662000i32 => {
9873                f.write_str("PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES")
9874            }
9875            1000664000i32 => f.write_str("UBM_SURFACE_CREATE_INFO"),
9876            1000673000i32 => {
9877                f.write_str("PHYSICAL_DEVICE_SHADER_MIXED_FLOAT_DOT_PRODUCT_FEATURES")
9878            }
9879            other => write!(f, "{}({})", stringify!(StructureType), other),
9880        }
9881    }
9882}
9883impl core::fmt::Display for StructureType {
9884    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9885        core::fmt::Debug::fmt(self, f)
9886    }
9887}
9888impl core::error::Error for StructureType {}
9889///[`VkSubpassContents`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassContents.html)
9890#[repr(transparent)]
9891#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9892#[doc(alias = "VkSubpassContents")]
9893pub struct SubpassContents(i32);
9894impl SubpassContents {
9895    pub const INLINE: Self = Self(0i32);
9896    pub const SECONDARY_COMMAND_BUFFERS: Self = Self(1i32);
9897    #[inline]
9898    pub const fn from_raw(value: i32) -> Self {
9899        Self(value)
9900    }
9901    #[inline]
9902    pub const fn as_raw(self) -> i32 {
9903        self.0
9904    }
9905}
9906impl core::fmt::Debug for SubpassContents {
9907    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9908        match self.0 {
9909            0i32 => f.write_str("INLINE"),
9910            1i32 => f.write_str("SECONDARY_COMMAND_BUFFERS"),
9911            other => write!(f, "{}({})", stringify!(SubpassContents), other),
9912        }
9913    }
9914}
9915impl core::fmt::Display for SubpassContents {
9916    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9917        core::fmt::Debug::fmt(self, f)
9918    }
9919}
9920impl core::error::Error for SubpassContents {}
9921///[`VkSubpassMergeStatusEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassMergeStatusEXT.html)
9922#[repr(transparent)]
9923#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9924#[doc(alias = "VkSubpassMergeStatusEXT")]
9925pub struct SubpassMergeStatusEXT(i32);
9926impl SubpassMergeStatusEXT {
9927    pub const MERGED: Self = Self(0i32);
9928    pub const DISALLOWED: Self = Self(1i32);
9929    pub const NOT_MERGED_SIDE_EFFECTS: Self = Self(2i32);
9930    pub const NOT_MERGED_SAMPLES_MISMATCH: Self = Self(3i32);
9931    pub const NOT_MERGED_VIEWS_MISMATCH: Self = Self(4i32);
9932    pub const NOT_MERGED_ALIASING: Self = Self(5i32);
9933    pub const NOT_MERGED_DEPENDENCIES: Self = Self(6i32);
9934    pub const NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT: Self = Self(7i32);
9935    pub const NOT_MERGED_TOO_MANY_ATTACHMENTS: Self = Self(8i32);
9936    pub const NOT_MERGED_INSUFFICIENT_STORAGE: Self = Self(9i32);
9937    pub const NOT_MERGED_DEPTH_STENCIL_COUNT: Self = Self(10i32);
9938    pub const NOT_MERGED_RESOLVE_ATTACHMENT_REUSE: Self = Self(11i32);
9939    pub const NOT_MERGED_SINGLE_SUBPASS: Self = Self(12i32);
9940    pub const NOT_MERGED_UNSPECIFIED: Self = Self(13i32);
9941    #[inline]
9942    pub const fn from_raw(value: i32) -> Self {
9943        Self(value)
9944    }
9945    #[inline]
9946    pub const fn as_raw(self) -> i32 {
9947        self.0
9948    }
9949}
9950impl core::fmt::Debug for SubpassMergeStatusEXT {
9951    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9952        match self.0 {
9953            0i32 => f.write_str("MERGED"),
9954            1i32 => f.write_str("DISALLOWED"),
9955            2i32 => f.write_str("NOT_MERGED_SIDE_EFFECTS"),
9956            3i32 => f.write_str("NOT_MERGED_SAMPLES_MISMATCH"),
9957            4i32 => f.write_str("NOT_MERGED_VIEWS_MISMATCH"),
9958            5i32 => f.write_str("NOT_MERGED_ALIASING"),
9959            6i32 => f.write_str("NOT_MERGED_DEPENDENCIES"),
9960            7i32 => f.write_str("NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT"),
9961            8i32 => f.write_str("NOT_MERGED_TOO_MANY_ATTACHMENTS"),
9962            9i32 => f.write_str("NOT_MERGED_INSUFFICIENT_STORAGE"),
9963            10i32 => f.write_str("NOT_MERGED_DEPTH_STENCIL_COUNT"),
9964            11i32 => f.write_str("NOT_MERGED_RESOLVE_ATTACHMENT_REUSE"),
9965            12i32 => f.write_str("NOT_MERGED_SINGLE_SUBPASS"),
9966            13i32 => f.write_str("NOT_MERGED_UNSPECIFIED"),
9967            other => write!(f, "{}({})", stringify!(SubpassMergeStatusEXT), other),
9968        }
9969    }
9970}
9971impl core::fmt::Display for SubpassMergeStatusEXT {
9972    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9973        core::fmt::Debug::fmt(self, f)
9974    }
9975}
9976impl core::error::Error for SubpassMergeStatusEXT {}
9977///[`VkSystemAllocationScope`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkSystemAllocationScope.html)
9978#[repr(transparent)]
9979#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
9980#[doc(alias = "VkSystemAllocationScope")]
9981pub struct SystemAllocationScope(i32);
9982impl SystemAllocationScope {
9983    pub const COMMAND: Self = Self(0i32);
9984    pub const OBJECT: Self = Self(1i32);
9985    pub const CACHE: Self = Self(2i32);
9986    pub const DEVICE: Self = Self(3i32);
9987    pub const INSTANCE: Self = Self(4i32);
9988    #[inline]
9989    pub const fn from_raw(value: i32) -> Self {
9990        Self(value)
9991    }
9992    #[inline]
9993    pub const fn as_raw(self) -> i32 {
9994        self.0
9995    }
9996}
9997impl core::fmt::Debug for SystemAllocationScope {
9998    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
9999        match self.0 {
10000            0i32 => f.write_str("COMMAND"),
10001            1i32 => f.write_str("OBJECT"),
10002            2i32 => f.write_str("CACHE"),
10003            3i32 => f.write_str("DEVICE"),
10004            4i32 => f.write_str("INSTANCE"),
10005            other => write!(f, "{}({})", stringify!(SystemAllocationScope), other),
10006        }
10007    }
10008}
10009impl core::fmt::Display for SystemAllocationScope {
10010    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10011        core::fmt::Debug::fmt(self, f)
10012    }
10013}
10014impl core::error::Error for SystemAllocationScope {}
10015///[`VkTensorTilingARM`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorTilingARM.html)
10016#[repr(transparent)]
10017#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10018#[doc(alias = "VkTensorTilingARM")]
10019pub struct TensorTilingARM(i32);
10020impl TensorTilingARM {
10021    pub const OPTIMAL: Self = Self(0i32);
10022    pub const LINEAR: Self = Self(1i32);
10023    #[inline]
10024    pub const fn from_raw(value: i32) -> Self {
10025        Self(value)
10026    }
10027    #[inline]
10028    pub const fn as_raw(self) -> i32 {
10029        self.0
10030    }
10031}
10032impl core::fmt::Debug for TensorTilingARM {
10033    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10034        match self.0 {
10035            0i32 => f.write_str("OPTIMAL"),
10036            1i32 => f.write_str("LINEAR"),
10037            other => write!(f, "{}({})", stringify!(TensorTilingARM), other),
10038        }
10039    }
10040}
10041impl core::fmt::Display for TensorTilingARM {
10042    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10043        core::fmt::Debug::fmt(self, f)
10044    }
10045}
10046impl core::error::Error for TensorTilingARM {}
10047///[`VkTessellationDomainOrigin`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTessellationDomainOrigin.html)
10048#[repr(transparent)]
10049#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10050#[doc(alias = "VkTessellationDomainOrigin")]
10051pub struct TessellationDomainOrigin(i32);
10052impl TessellationDomainOrigin {
10053    pub const UPPER_LEFT: Self = Self(0i32);
10054    pub const LOWER_LEFT: Self = Self(1i32);
10055    #[inline]
10056    pub const fn from_raw(value: i32) -> Self {
10057        Self(value)
10058    }
10059    #[inline]
10060    pub const fn as_raw(self) -> i32 {
10061        self.0
10062    }
10063}
10064impl core::fmt::Debug for TessellationDomainOrigin {
10065    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10066        match self.0 {
10067            0i32 => f.write_str("UPPER_LEFT"),
10068            1i32 => f.write_str("LOWER_LEFT"),
10069            other => write!(f, "{}({})", stringify!(TessellationDomainOrigin), other),
10070        }
10071    }
10072}
10073impl core::fmt::Display for TessellationDomainOrigin {
10074    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10075        core::fmt::Debug::fmt(self, f)
10076    }
10077}
10078impl core::error::Error for TessellationDomainOrigin {}
10079///[`VkTimeDomainKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkTimeDomainKHR.html)
10080#[repr(transparent)]
10081#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10082#[doc(alias = "VkTimeDomainKHR")]
10083pub struct TimeDomainKHR(i32);
10084impl TimeDomainKHR {
10085    pub const DEVICE: Self = Self(0i32);
10086    pub const CLOCK_MONOTONIC: Self = Self(1i32);
10087    pub const CLOCK_MONOTONIC_RAW: Self = Self(2i32);
10088    pub const QUERY_PERFORMANCE_COUNTER: Self = Self(3i32);
10089    pub const PRESENT_STAGE_LOCAL: Self = Self(1000208000i32);
10090    pub const SWAPCHAIN_LOCAL: Self = Self(1000208001i32);
10091    #[inline]
10092    pub const fn from_raw(value: i32) -> Self {
10093        Self(value)
10094    }
10095    #[inline]
10096    pub const fn as_raw(self) -> i32 {
10097        self.0
10098    }
10099}
10100impl core::fmt::Debug for TimeDomainKHR {
10101    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10102        match self.0 {
10103            0i32 => f.write_str("DEVICE"),
10104            1i32 => f.write_str("CLOCK_MONOTONIC"),
10105            2i32 => f.write_str("CLOCK_MONOTONIC_RAW"),
10106            3i32 => f.write_str("QUERY_PERFORMANCE_COUNTER"),
10107            1000208000i32 => f.write_str("PRESENT_STAGE_LOCAL"),
10108            1000208001i32 => f.write_str("SWAPCHAIN_LOCAL"),
10109            other => write!(f, "{}({})", stringify!(TimeDomainKHR), other),
10110        }
10111    }
10112}
10113impl core::fmt::Display for TimeDomainKHR {
10114    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10115        core::fmt::Debug::fmt(self, f)
10116    }
10117}
10118impl core::error::Error for TimeDomainKHR {}
10119///[`VkValidationCacheHeaderVersionEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheHeaderVersionEXT.html)
10120#[repr(transparent)]
10121#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10122#[doc(alias = "VkValidationCacheHeaderVersionEXT")]
10123pub struct ValidationCacheHeaderVersionEXT(i32);
10124impl ValidationCacheHeaderVersionEXT {
10125    pub const ONE: Self = Self(1i32);
10126    #[inline]
10127    pub const fn from_raw(value: i32) -> Self {
10128        Self(value)
10129    }
10130    #[inline]
10131    pub const fn as_raw(self) -> i32 {
10132        self.0
10133    }
10134}
10135impl core::fmt::Debug for ValidationCacheHeaderVersionEXT {
10136    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10137        match self.0 {
10138            1i32 => f.write_str("ONE"),
10139            other => {
10140                write!(f, "{}({})", stringify!(ValidationCacheHeaderVersionEXT), other)
10141            }
10142        }
10143    }
10144}
10145impl core::fmt::Display for ValidationCacheHeaderVersionEXT {
10146    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10147        core::fmt::Debug::fmt(self, f)
10148    }
10149}
10150impl core::error::Error for ValidationCacheHeaderVersionEXT {}
10151///[`VkValidationCheckEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCheckEXT.html)
10152#[repr(transparent)]
10153#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10154#[doc(alias = "VkValidationCheckEXT")]
10155pub struct ValidationCheckEXT(i32);
10156impl ValidationCheckEXT {
10157    pub const ALL: Self = Self(0i32);
10158    pub const SHADERS: Self = Self(1i32);
10159    #[inline]
10160    pub const fn from_raw(value: i32) -> Self {
10161        Self(value)
10162    }
10163    #[inline]
10164    pub const fn as_raw(self) -> i32 {
10165        self.0
10166    }
10167}
10168impl core::fmt::Debug for ValidationCheckEXT {
10169    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10170        match self.0 {
10171            0i32 => f.write_str("ALL"),
10172            1i32 => f.write_str("SHADERS"),
10173            other => write!(f, "{}({})", stringify!(ValidationCheckEXT), other),
10174        }
10175    }
10176}
10177impl core::fmt::Display for ValidationCheckEXT {
10178    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10179        core::fmt::Debug::fmt(self, f)
10180    }
10181}
10182impl core::error::Error for ValidationCheckEXT {}
10183///[`VkValidationFeatureDisableEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFeatureDisableEXT.html)
10184#[repr(transparent)]
10185#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10186#[doc(alias = "VkValidationFeatureDisableEXT")]
10187pub struct ValidationFeatureDisableEXT(i32);
10188impl ValidationFeatureDisableEXT {
10189    pub const ALL: Self = Self(0i32);
10190    pub const SHADERS: Self = Self(1i32);
10191    pub const THREAD_SAFETY: Self = Self(2i32);
10192    pub const API_PARAMETERS: Self = Self(3i32);
10193    pub const OBJECT_LIFETIMES: Self = Self(4i32);
10194    pub const CORE_CHECKS: Self = Self(5i32);
10195    pub const UNIQUE_HANDLES: Self = Self(6i32);
10196    pub const SHADER_VALIDATION_CACHE: Self = Self(7i32);
10197    #[inline]
10198    pub const fn from_raw(value: i32) -> Self {
10199        Self(value)
10200    }
10201    #[inline]
10202    pub const fn as_raw(self) -> i32 {
10203        self.0
10204    }
10205}
10206impl core::fmt::Debug for ValidationFeatureDisableEXT {
10207    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10208        match self.0 {
10209            0i32 => f.write_str("ALL"),
10210            1i32 => f.write_str("SHADERS"),
10211            2i32 => f.write_str("THREAD_SAFETY"),
10212            3i32 => f.write_str("API_PARAMETERS"),
10213            4i32 => f.write_str("OBJECT_LIFETIMES"),
10214            5i32 => f.write_str("CORE_CHECKS"),
10215            6i32 => f.write_str("UNIQUE_HANDLES"),
10216            7i32 => f.write_str("SHADER_VALIDATION_CACHE"),
10217            other => write!(f, "{}({})", stringify!(ValidationFeatureDisableEXT), other),
10218        }
10219    }
10220}
10221impl core::fmt::Display for ValidationFeatureDisableEXT {
10222    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10223        core::fmt::Debug::fmt(self, f)
10224    }
10225}
10226impl core::error::Error for ValidationFeatureDisableEXT {}
10227///[`VkValidationFeatureEnableEXT`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFeatureEnableEXT.html)
10228#[repr(transparent)]
10229#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10230#[doc(alias = "VkValidationFeatureEnableEXT")]
10231pub struct ValidationFeatureEnableEXT(i32);
10232impl ValidationFeatureEnableEXT {
10233    pub const GPU_ASSISTED: Self = Self(0i32);
10234    pub const GPU_ASSISTED_RESERVE_BINDING_SLOT: Self = Self(1i32);
10235    pub const BEST_PRACTICES: Self = Self(2i32);
10236    pub const DEBUG_PRINTF: Self = Self(3i32);
10237    pub const SYNCHRONIZATION_VALIDATION: Self = Self(4i32);
10238    #[inline]
10239    pub const fn from_raw(value: i32) -> Self {
10240        Self(value)
10241    }
10242    #[inline]
10243    pub const fn as_raw(self) -> i32 {
10244        self.0
10245    }
10246}
10247impl core::fmt::Debug for ValidationFeatureEnableEXT {
10248    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10249        match self.0 {
10250            0i32 => f.write_str("GPU_ASSISTED"),
10251            1i32 => f.write_str("GPU_ASSISTED_RESERVE_BINDING_SLOT"),
10252            2i32 => f.write_str("BEST_PRACTICES"),
10253            3i32 => f.write_str("DEBUG_PRINTF"),
10254            4i32 => f.write_str("SYNCHRONIZATION_VALIDATION"),
10255            other => write!(f, "{}({})", stringify!(ValidationFeatureEnableEXT), other),
10256        }
10257    }
10258}
10259impl core::fmt::Display for ValidationFeatureEnableEXT {
10260    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10261        core::fmt::Debug::fmt(self, f)
10262    }
10263}
10264impl core::error::Error for ValidationFeatureEnableEXT {}
10265///[`VkVendorId`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVendorId.html)
10266#[repr(transparent)]
10267#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10268#[doc(alias = "VkVendorId")]
10269pub struct VendorId(i32);
10270impl VendorId {
10271    ///Khronos vendor ID
10272    pub const KHRONOS: Self = Self(65536i32);
10273    ///Vivante vendor ID
10274    pub const VIV: Self = Self(65537i32);
10275    ///VeriSilicon vendor ID
10276    pub const VSI: Self = Self(65538i32);
10277    ///Kazan Software Renderer
10278    pub const KAZAN: Self = Self(65539i32);
10279    ///Codeplay Software Ltd. vendor ID
10280    pub const CODEPLAY: Self = Self(65540i32);
10281    ///PoCL vendor ID
10282    pub const POCL: Self = Self(65542i32);
10283    ///Mobileye vendor ID
10284    pub const MOBILEYE: Self = Self(65543i32);
10285    #[inline]
10286    pub const fn from_raw(value: i32) -> Self {
10287        Self(value)
10288    }
10289    #[inline]
10290    pub const fn as_raw(self) -> i32 {
10291        self.0
10292    }
10293}
10294impl core::fmt::Debug for VendorId {
10295    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10296        match self.0 {
10297            65536i32 => f.write_str("KHRONOS"),
10298            65537i32 => f.write_str("VIV"),
10299            65538i32 => f.write_str("VSI"),
10300            65539i32 => f.write_str("KAZAN"),
10301            65540i32 => f.write_str("CODEPLAY"),
10302            65542i32 => f.write_str("POCL"),
10303            65543i32 => f.write_str("MOBILEYE"),
10304            other => write!(f, "{}({})", stringify!(VendorId), other),
10305        }
10306    }
10307}
10308impl core::fmt::Display for VendorId {
10309    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10310        core::fmt::Debug::fmt(self, f)
10311    }
10312}
10313impl core::error::Error for VendorId {}
10314///[`VkVertexInputRate`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputRate.html)
10315#[repr(transparent)]
10316#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10317#[doc(alias = "VkVertexInputRate")]
10318pub struct VertexInputRate(i32);
10319impl VertexInputRate {
10320    pub const VERTEX: Self = Self(0i32);
10321    pub const INSTANCE: Self = Self(1i32);
10322    #[inline]
10323    pub const fn from_raw(value: i32) -> Self {
10324        Self(value)
10325    }
10326    #[inline]
10327    pub const fn as_raw(self) -> i32 {
10328        self.0
10329    }
10330}
10331impl core::fmt::Debug for VertexInputRate {
10332    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10333        match self.0 {
10334            0i32 => f.write_str("VERTEX"),
10335            1i32 => f.write_str("INSTANCE"),
10336            other => write!(f, "{}({})", stringify!(VertexInputRate), other),
10337        }
10338    }
10339}
10340impl core::fmt::Display for VertexInputRate {
10341    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10342        core::fmt::Debug::fmt(self, f)
10343    }
10344}
10345impl core::error::Error for VertexInputRate {}
10346///[`VkVideoEncodeAV1PredictionModeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1PredictionModeKHR.html)
10347#[repr(transparent)]
10348#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10349#[doc(alias = "VkVideoEncodeAV1PredictionModeKHR")]
10350pub struct VideoEncodeAV1PredictionModeKHR(i32);
10351impl VideoEncodeAV1PredictionModeKHR {
10352    pub const INTRA_ONLY: Self = Self(0i32);
10353    pub const SINGLE_REFERENCE: Self = Self(1i32);
10354    pub const UNIDIRECTIONAL_COMPOUND: Self = Self(2i32);
10355    pub const BIDIRECTIONAL_COMPOUND: Self = Self(3i32);
10356    #[inline]
10357    pub const fn from_raw(value: i32) -> Self {
10358        Self(value)
10359    }
10360    #[inline]
10361    pub const fn as_raw(self) -> i32 {
10362        self.0
10363    }
10364}
10365impl core::fmt::Debug for VideoEncodeAV1PredictionModeKHR {
10366    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10367        match self.0 {
10368            0i32 => f.write_str("INTRA_ONLY"),
10369            1i32 => f.write_str("SINGLE_REFERENCE"),
10370            2i32 => f.write_str("UNIDIRECTIONAL_COMPOUND"),
10371            3i32 => f.write_str("BIDIRECTIONAL_COMPOUND"),
10372            other => {
10373                write!(f, "{}({})", stringify!(VideoEncodeAV1PredictionModeKHR), other)
10374            }
10375        }
10376    }
10377}
10378impl core::fmt::Display for VideoEncodeAV1PredictionModeKHR {
10379    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10380        core::fmt::Debug::fmt(self, f)
10381    }
10382}
10383impl core::error::Error for VideoEncodeAV1PredictionModeKHR {}
10384///[`VkVideoEncodeAV1RateControlGroupKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlGroupKHR.html)
10385#[repr(transparent)]
10386#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10387#[doc(alias = "VkVideoEncodeAV1RateControlGroupKHR")]
10388pub struct VideoEncodeAV1RateControlGroupKHR(i32);
10389impl VideoEncodeAV1RateControlGroupKHR {
10390    pub const INTRA: Self = Self(0i32);
10391    pub const PREDICTIVE: Self = Self(1i32);
10392    pub const BIPREDICTIVE: Self = Self(2i32);
10393    #[inline]
10394    pub const fn from_raw(value: i32) -> Self {
10395        Self(value)
10396    }
10397    #[inline]
10398    pub const fn as_raw(self) -> i32 {
10399        self.0
10400    }
10401}
10402impl core::fmt::Debug for VideoEncodeAV1RateControlGroupKHR {
10403    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10404        match self.0 {
10405            0i32 => f.write_str("INTRA"),
10406            1i32 => f.write_str("PREDICTIVE"),
10407            2i32 => f.write_str("BIPREDICTIVE"),
10408            other => {
10409                write!(f, "{}({})", stringify!(VideoEncodeAV1RateControlGroupKHR), other)
10410            }
10411        }
10412    }
10413}
10414impl core::fmt::Display for VideoEncodeAV1RateControlGroupKHR {
10415    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10416        core::fmt::Debug::fmt(self, f)
10417    }
10418}
10419impl core::error::Error for VideoEncodeAV1RateControlGroupKHR {}
10420///[`VkVideoEncodeTuningModeKHR`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeTuningModeKHR.html)
10421#[repr(transparent)]
10422#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10423#[doc(alias = "VkVideoEncodeTuningModeKHR")]
10424pub struct VideoEncodeTuningModeKHR(i32);
10425impl VideoEncodeTuningModeKHR {
10426    pub const DEFAULT: Self = Self(0i32);
10427    pub const HIGH_QUALITY: Self = Self(1i32);
10428    pub const LOW_LATENCY: Self = Self(2i32);
10429    pub const ULTRA_LOW_LATENCY: Self = Self(3i32);
10430    pub const LOSSLESS: Self = Self(4i32);
10431    #[inline]
10432    pub const fn from_raw(value: i32) -> Self {
10433        Self(value)
10434    }
10435    #[inline]
10436    pub const fn as_raw(self) -> i32 {
10437        self.0
10438    }
10439}
10440impl core::fmt::Debug for VideoEncodeTuningModeKHR {
10441    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10442        match self.0 {
10443            0i32 => f.write_str("DEFAULT"),
10444            1i32 => f.write_str("HIGH_QUALITY"),
10445            2i32 => f.write_str("LOW_LATENCY"),
10446            3i32 => f.write_str("ULTRA_LOW_LATENCY"),
10447            4i32 => f.write_str("LOSSLESS"),
10448            other => write!(f, "{}({})", stringify!(VideoEncodeTuningModeKHR), other),
10449        }
10450    }
10451}
10452impl core::fmt::Display for VideoEncodeTuningModeKHR {
10453    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10454        core::fmt::Debug::fmt(self, f)
10455    }
10456}
10457impl core::error::Error for VideoEncodeTuningModeKHR {}
10458///[`VkViewportCoordinateSwizzleNV`](https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewportCoordinateSwizzleNV.html)
10459#[repr(transparent)]
10460#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
10461#[doc(alias = "VkViewportCoordinateSwizzleNV")]
10462pub struct ViewportCoordinateSwizzleNV(i32);
10463impl ViewportCoordinateSwizzleNV {
10464    pub const POSITIVE_X: Self = Self(0i32);
10465    pub const NEGATIVE_X: Self = Self(1i32);
10466    pub const POSITIVE_Y: Self = Self(2i32);
10467    pub const NEGATIVE_Y: Self = Self(3i32);
10468    pub const POSITIVE_Z: Self = Self(4i32);
10469    pub const NEGATIVE_Z: Self = Self(5i32);
10470    pub const POSITIVE_W: Self = Self(6i32);
10471    pub const NEGATIVE_W: Self = Self(7i32);
10472    #[inline]
10473    pub const fn from_raw(value: i32) -> Self {
10474        Self(value)
10475    }
10476    #[inline]
10477    pub const fn as_raw(self) -> i32 {
10478        self.0
10479    }
10480}
10481impl core::fmt::Debug for ViewportCoordinateSwizzleNV {
10482    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10483        match self.0 {
10484            0i32 => f.write_str("POSITIVE_X"),
10485            1i32 => f.write_str("NEGATIVE_X"),
10486            2i32 => f.write_str("POSITIVE_Y"),
10487            3i32 => f.write_str("NEGATIVE_Y"),
10488            4i32 => f.write_str("POSITIVE_Z"),
10489            5i32 => f.write_str("NEGATIVE_Z"),
10490            6i32 => f.write_str("POSITIVE_W"),
10491            7i32 => f.write_str("NEGATIVE_W"),
10492            other => write!(f, "{}({})", stringify!(ViewportCoordinateSwizzleNV), other),
10493        }
10494    }
10495}
10496impl core::fmt::Display for ViewportCoordinateSwizzleNV {
10497    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
10498        core::fmt::Debug::fmt(self, f)
10499    }
10500}
10501impl core::error::Error for ViewportCoordinateSwizzleNV {}
vulkan_rust_sys/enums.rs

vulkan_rust_sys/
enums.rs
