dawn-sys 1.0.3

/* automatically generated by rust-bindgen 0.71.1 */

pub const _VCRT_COMPILER_PREPROCESSOR: u32 = 1;
pub const _SAL_VERSION: u32 = 20;
pub const __SAL_H_VERSION: u32 = 180000000;
pub const _USE_DECLSPECS_FOR_SAL: u32 = 0;
pub const _USE_ATTRIBUTES_FOR_SAL: u32 = 0;
pub const _CRT_PACKING: u32 = 8;
pub const _HAS_EXCEPTIONS: u32 = 1;
pub const _STL_LANG: u32 = 0;
pub const _HAS_CXX17: u32 = 0;
pub const _HAS_CXX20: u32 = 0;
pub const _HAS_CXX23: u32 = 0;
pub const _HAS_CXX26: u32 = 0;
pub const _HAS_NODISCARD: u32 = 0;
pub const WCHAR_MIN: u32 = 0;
pub const WCHAR_MAX: u32 = 65535;
pub const WINT_MIN: u32 = 0;
pub const WINT_MAX: u32 = 65535;
pub const _ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE: u32 = 1;
pub const _CRT_BUILD_DESKTOP_APP: u32 = 1;
pub const _ARGMAX: u32 = 100;
pub const _CRT_INT_MAX: u32 = 2147483647;
pub const _CRT_FUNCTIONS_REQUIRED: u32 = 1;
pub const _CRT_HAS_CXX17: u32 = 0;
pub const _CRT_HAS_C11: u32 = 1;
pub const _CRT_INTERNAL_NONSTDC_NAMES: u32 = 1;
pub const __STDC_SECURE_LIB__: u32 = 200411;
pub const __GOT_SECURE_LIB__: u32 = 200411;
pub const __STDC_WANT_SECURE_LIB__: u32 = 1;
pub const _SECURECRT_FILL_BUFFER_PATTERN: u32 = 254;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES: u32 = 1;
pub const _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY: u32 = 0;
pub const _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY: u32 = 0;
pub const _DOMAIN: u32 = 1;
pub const _SING: u32 = 2;
pub const _OVERFLOW: u32 = 3;
pub const _UNDERFLOW: u32 = 4;
pub const _TLOSS: u32 = 5;
pub const _PLOSS: u32 = 6;
pub const _HUGE_ENUF : f64 = 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 ;
pub const _DENORM: i32 = -2;
pub const _FINITE: i32 = -1;
pub const _INFCODE: u32 = 1;
pub const _NANCODE: u32 = 2;
pub const FP_INFINITE: u32 = 1;
pub const FP_NAN: u32 = 2;
pub const FP_NORMAL: i32 = -1;
pub const FP_SUBNORMAL: i32 = -2;
pub const FP_ZERO: u32 = 0;
pub const _C2: u32 = 1;
pub const FP_ILOGB0: i32 = -2147483648;
pub const FP_ILOGBNAN: u32 = 2147483647;
pub const MATH_ERRNO: u32 = 1;
pub const MATH_ERREXCEPT: u32 = 2;
pub const math_errhandling: u32 = 3;
pub const _FE_DIVBYZERO: u32 = 4;
pub const _FE_INEXACT: u32 = 32;
pub const _FE_INVALID: u32 = 1;
pub const _FE_OVERFLOW: u32 = 8;
pub const _FE_UNDERFLOW: u32 = 16;
pub const _D0_C: u32 = 3;
pub const _D1_C: u32 = 2;
pub const _D2_C: u32 = 1;
pub const _D3_C: u32 = 0;
pub const _DBIAS: u32 = 1022;
pub const _DOFF: u32 = 4;
pub const _F0_C: u32 = 1;
pub const _F1_C: u32 = 0;
pub const _FBIAS: u32 = 126;
pub const _FOFF: u32 = 7;
pub const _FRND: u32 = 1;
pub const _L0_C: u32 = 3;
pub const _L1_C: u32 = 2;
pub const _L2_C: u32 = 1;
pub const _L3_C: u32 = 0;
pub const _LBIAS: u32 = 1022;
pub const _LOFF: u32 = 4;
pub const _FP_LT: u32 = 1;
pub const _FP_EQ: u32 = 2;
pub const _FP_GT: u32 = 4;
pub const DOMAIN: u32 = 1;
pub const SING: u32 = 2;
pub const OVERFLOW: u32 = 3;
pub const UNDERFLOW: u32 = 4;
pub const TLOSS: u32 = 5;
pub const PLOSS: u32 = 6;
pub type va_list = *mut ::core::ffi::c_char;
unsafe extern "C" {
    pub fn __va_start(arg1: *mut *mut ::core::ffi::c_char, ...);
}
pub type __vcrt_bool = bool;
pub type wchar_t = ::core::ffi::c_ushort;
unsafe extern "C" {
    pub fn __security_init_cookie();
}
unsafe extern "C" {
    pub fn __security_check_cookie(_StackCookie: usize);
}
unsafe extern "C" {
    pub fn __report_gsfailure(_StackCookie: usize) -> !;
}
unsafe extern "C" {
    pub static mut __security_cookie: usize;
}
pub type int_least8_t = ::core::ffi::c_schar;
pub type int_least16_t = ::core::ffi::c_short;
pub type int_least32_t = ::core::ffi::c_int;
pub type int_least64_t = ::core::ffi::c_longlong;
pub type uint_least8_t = ::core::ffi::c_uchar;
pub type uint_least16_t = ::core::ffi::c_ushort;
pub type uint_least32_t = ::core::ffi::c_uint;
pub type uint_least64_t = ::core::ffi::c_ulonglong;
pub type int_fast8_t = ::core::ffi::c_schar;
pub type int_fast16_t = ::core::ffi::c_int;
pub type int_fast32_t = ::core::ffi::c_int;
pub type int_fast64_t = ::core::ffi::c_longlong;
pub type uint_fast8_t = ::core::ffi::c_uchar;
pub type uint_fast16_t = ::core::ffi::c_uint;
pub type uint_fast32_t = ::core::ffi::c_uint;
pub type uint_fast64_t = ::core::ffi::c_ulonglong;
pub type intmax_t = ::core::ffi::c_longlong;
pub type uintmax_t = ::core::ffi::c_ulonglong;
pub type __crt_bool = bool;
unsafe extern "C" {
    pub fn _invalid_parameter_noinfo();
}
unsafe extern "C" {
    pub fn _invalid_parameter_noinfo_noreturn() -> !;
}
unsafe extern "C" {
    pub fn _invoke_watson(
        _Expression: *const wchar_t,
        _FunctionName: *const wchar_t,
        _FileName: *const wchar_t,
        _LineNo: ::core::ffi::c_uint,
        _Reserved: usize,
    ) -> !;
}
pub type errno_t = ::core::ffi::c_int;
pub type wint_t = ::core::ffi::c_ushort;
pub type wctype_t = ::core::ffi::c_ushort;
pub type __time32_t = ::core::ffi::c_long;
pub type __time64_t = ::core::ffi::c_longlong;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __crt_locale_data_public {
    pub _locale_pctype: *const ::core::ffi::c_ushort,
    pub _locale_mb_cur_max: ::core::ffi::c_int,
    pub _locale_lc_codepage: ::core::ffi::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __crt_locale_data_public"]
        [::core::mem::size_of::<__crt_locale_data_public>() - 16usize];
    ["Alignment of __crt_locale_data_public"]
        [::core::mem::align_of::<__crt_locale_data_public>() - 8usize];
    ["Offset of field: __crt_locale_data_public::_locale_pctype"]
        [::core::mem::offset_of!(__crt_locale_data_public, _locale_pctype) - 0usize];
    ["Offset of field: __crt_locale_data_public::_locale_mb_cur_max"]
        [::core::mem::offset_of!(__crt_locale_data_public, _locale_mb_cur_max) - 8usize];
    ["Offset of field: __crt_locale_data_public::_locale_lc_codepage"]
        [::core::mem::offset_of!(__crt_locale_data_public, _locale_lc_codepage) - 12usize];
};
impl Default for __crt_locale_data_public {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __crt_locale_pointers {
    pub locinfo: *mut __crt_locale_data,
    pub mbcinfo: *mut __crt_multibyte_data,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of __crt_locale_pointers"][::core::mem::size_of::<__crt_locale_pointers>() - 16usize];
    ["Alignment of __crt_locale_pointers"]
        [::core::mem::align_of::<__crt_locale_pointers>() - 8usize];
    ["Offset of field: __crt_locale_pointers::locinfo"]
        [::core::mem::offset_of!(__crt_locale_pointers, locinfo) - 0usize];
    ["Offset of field: __crt_locale_pointers::mbcinfo"]
        [::core::mem::offset_of!(__crt_locale_pointers, mbcinfo) - 8usize];
};
impl Default for __crt_locale_pointers {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type _locale_t = *mut __crt_locale_pointers;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct _Mbstatet {
    pub _Wchar: ::core::ffi::c_ulong,
    pub _Byte: ::core::ffi::c_ushort,
    pub _State: ::core::ffi::c_ushort,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _Mbstatet"][::core::mem::size_of::<_Mbstatet>() - 8usize];
    ["Alignment of _Mbstatet"][::core::mem::align_of::<_Mbstatet>() - 4usize];
    ["Offset of field: _Mbstatet::_Wchar"][::core::mem::offset_of!(_Mbstatet, _Wchar) - 0usize];
    ["Offset of field: _Mbstatet::_Byte"][::core::mem::offset_of!(_Mbstatet, _Byte) - 4usize];
    ["Offset of field: _Mbstatet::_State"][::core::mem::offset_of!(_Mbstatet, _State) - 6usize];
};
pub type mbstate_t = _Mbstatet;
pub type time_t = __time64_t;
pub type rsize_t = usize;
unsafe extern "C" {
    pub fn _errno() -> *mut ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _set_errno(_Value: ::core::ffi::c_int) -> errno_t;
}
unsafe extern "C" {
    pub fn _get_errno(_Value: *mut ::core::ffi::c_int) -> errno_t;
}
unsafe extern "C" {
    pub fn __threadid() -> ::core::ffi::c_ulong;
}
unsafe extern "C" {
    pub fn __threadhandle() -> usize;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct _exception {
    pub type_: ::core::ffi::c_int,
    pub name: *mut ::core::ffi::c_char,
    pub arg1: f64,
    pub arg2: f64,
    pub retval: f64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _exception"][::core::mem::size_of::<_exception>() - 40usize];
    ["Alignment of _exception"][::core::mem::align_of::<_exception>() - 8usize];
    ["Offset of field: _exception::type_"][::core::mem::offset_of!(_exception, type_) - 0usize];
    ["Offset of field: _exception::name"][::core::mem::offset_of!(_exception, name) - 8usize];
    ["Offset of field: _exception::arg1"][::core::mem::offset_of!(_exception, arg1) - 16usize];
    ["Offset of field: _exception::arg2"][::core::mem::offset_of!(_exception, arg2) - 24usize];
    ["Offset of field: _exception::retval"][::core::mem::offset_of!(_exception, retval) - 32usize];
};
impl Default for _exception {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
pub struct _complex {
    pub x: f64,
    pub y: f64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _complex"][::core::mem::size_of::<_complex>() - 16usize];
    ["Alignment of _complex"][::core::mem::align_of::<_complex>() - 8usize];
    ["Offset of field: _complex::x"][::core::mem::offset_of!(_complex, x) - 0usize];
    ["Offset of field: _complex::y"][::core::mem::offset_of!(_complex, y) - 8usize];
};
pub type float_t = f32;
pub type double_t = f64;
unsafe extern "C" {
    pub static _HUGE: f64;
}
unsafe extern "C" {
    pub fn _fperrraise(_Except: ::core::ffi::c_int);
}
unsafe extern "C" {
    pub fn _dclass(_X: f64) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _ldclass(_X: f64) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _fdclass(_X: f32) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _dsign(_X: f64) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _ldsign(_X: f64) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _fdsign(_X: f32) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _dpcomp(_X: f64, _Y: f64) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _ldpcomp(_X: f64, _Y: f64) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _fdpcomp(_X: f32, _Y: f32) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _dtest(_Px: *mut f64) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _ldtest(_Px: *mut f64) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _fdtest(_Px: *mut f32) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _d_int(_Px: *mut f64, _Xexp: ::core::ffi::c_short) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _ld_int(_Px: *mut f64, _Xexp: ::core::ffi::c_short) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _fd_int(_Px: *mut f32, _Xexp: ::core::ffi::c_short) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _dscale(_Px: *mut f64, _Lexp: ::core::ffi::c_long) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _ldscale(_Px: *mut f64, _Lexp: ::core::ffi::c_long) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _fdscale(_Px: *mut f32, _Lexp: ::core::ffi::c_long) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _dunscale(_Pex: *mut ::core::ffi::c_short, _Px: *mut f64) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _ldunscale(_Pex: *mut ::core::ffi::c_short, _Px: *mut f64) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _fdunscale(_Pex: *mut ::core::ffi::c_short, _Px: *mut f32) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _dexp(_Px: *mut f64, _Y: f64, _Eoff: ::core::ffi::c_long) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _ldexp(_Px: *mut f64, _Y: f64, _Eoff: ::core::ffi::c_long) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _fdexp(_Px: *mut f32, _Y: f32, _Eoff: ::core::ffi::c_long) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _dnorm(_Ps: *mut ::core::ffi::c_ushort) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _fdnorm(_Ps: *mut ::core::ffi::c_ushort) -> ::core::ffi::c_short;
}
unsafe extern "C" {
    pub fn _dpoly(_X: f64, _Tab: *const f64, _N: ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn _ldpoly(_X: f64, _Tab: *const f64, _N: ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn _fdpoly(_X: f32, _Tab: *const f32, _N: ::core::ffi::c_int) -> f32;
}
unsafe extern "C" {
    pub fn _dlog(_X: f64, _Baseflag: ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn _ldlog(_X: f64, _Baseflag: ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn _fdlog(_X: f32, _Baseflag: ::core::ffi::c_int) -> f32;
}
unsafe extern "C" {
    pub fn _dsin(_X: f64, _Qoff: ::core::ffi::c_uint) -> f64;
}
unsafe extern "C" {
    pub fn _ldsin(_X: f64, _Qoff: ::core::ffi::c_uint) -> f64;
}
unsafe extern "C" {
    pub fn _fdsin(_X: f32, _Qoff: ::core::ffi::c_uint) -> f32;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _double_val {
    pub _Sh: [::core::ffi::c_ushort; 4usize],
    pub _Val: f64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _double_val"][::core::mem::size_of::<_double_val>() - 8usize];
    ["Alignment of _double_val"][::core::mem::align_of::<_double_val>() - 8usize];
    ["Offset of field: _double_val::_Sh"][::core::mem::offset_of!(_double_val, _Sh) - 0usize];
    ["Offset of field: _double_val::_Val"][::core::mem::offset_of!(_double_val, _Val) - 0usize];
};
impl Default for _double_val {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _float_val {
    pub _Sh: [::core::ffi::c_ushort; 2usize],
    pub _Val: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _float_val"][::core::mem::size_of::<_float_val>() - 4usize];
    ["Alignment of _float_val"][::core::mem::align_of::<_float_val>() - 4usize];
    ["Offset of field: _float_val::_Sh"][::core::mem::offset_of!(_float_val, _Sh) - 0usize];
    ["Offset of field: _float_val::_Val"][::core::mem::offset_of!(_float_val, _Val) - 0usize];
};
impl Default for _float_val {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _ldouble_val {
    pub _Sh: [::core::ffi::c_ushort; 4usize],
    pub _Val: f64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _ldouble_val"][::core::mem::size_of::<_ldouble_val>() - 8usize];
    ["Alignment of _ldouble_val"][::core::mem::align_of::<_ldouble_val>() - 8usize];
    ["Offset of field: _ldouble_val::_Sh"][::core::mem::offset_of!(_ldouble_val, _Sh) - 0usize];
    ["Offset of field: _ldouble_val::_Val"][::core::mem::offset_of!(_ldouble_val, _Val) - 0usize];
};
impl Default for _ldouble_val {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union _float_const {
    pub _Word: [::core::ffi::c_ushort; 4usize],
    pub _Float: f32,
    pub _Double: f64,
    pub _Long_double: f64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of _float_const"][::core::mem::size_of::<_float_const>() - 8usize];
    ["Alignment of _float_const"][::core::mem::align_of::<_float_const>() - 8usize];
    ["Offset of field: _float_const::_Word"][::core::mem::offset_of!(_float_const, _Word) - 0usize];
    ["Offset of field: _float_const::_Float"]
        [::core::mem::offset_of!(_float_const, _Float) - 0usize];
    ["Offset of field: _float_const::_Double"]
        [::core::mem::offset_of!(_float_const, _Double) - 0usize];
    ["Offset of field: _float_const::_Long_double"]
        [::core::mem::offset_of!(_float_const, _Long_double) - 0usize];
};
impl Default for _float_const {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    pub static _Denorm_C: _float_const;
}
unsafe extern "C" {
    pub static _Inf_C: _float_const;
}
unsafe extern "C" {
    pub static _Nan_C: _float_const;
}
unsafe extern "C" {
    pub static _Snan_C: _float_const;
}
unsafe extern "C" {
    pub static _Hugeval_C: _float_const;
}
unsafe extern "C" {
    pub static _FDenorm_C: _float_const;
}
unsafe extern "C" {
    pub static _FInf_C: _float_const;
}
unsafe extern "C" {
    pub static _FNan_C: _float_const;
}
unsafe extern "C" {
    pub static _FSnan_C: _float_const;
}
unsafe extern "C" {
    pub static _LDenorm_C: _float_const;
}
unsafe extern "C" {
    pub static _LInf_C: _float_const;
}
unsafe extern "C" {
    pub static _LNan_C: _float_const;
}
unsafe extern "C" {
    pub static _LSnan_C: _float_const;
}
unsafe extern "C" {
    pub static _Eps_C: _float_const;
}
unsafe extern "C" {
    pub static _Rteps_C: _float_const;
}
unsafe extern "C" {
    pub static _FEps_C: _float_const;
}
unsafe extern "C" {
    pub static _FRteps_C: _float_const;
}
unsafe extern "C" {
    pub static _LEps_C: _float_const;
}
unsafe extern "C" {
    pub static _LRteps_C: _float_const;
}
unsafe extern "C" {
    pub static _Zero_C: f64;
}
unsafe extern "C" {
    pub static _Xbig_C: f64;
}
unsafe extern "C" {
    pub static _FZero_C: f32;
}
unsafe extern "C" {
    pub static _FXbig_C: f32;
}
unsafe extern "C" {
    pub static _LZero_C: f64;
}
unsafe extern "C" {
    pub static _LXbig_C: f64;
}
unsafe extern "C" {
    pub fn abs(_X: ::core::ffi::c_int) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn labs(_X: ::core::ffi::c_long) -> ::core::ffi::c_long;
}
unsafe extern "C" {
    pub fn llabs(_X: ::core::ffi::c_longlong) -> ::core::ffi::c_longlong;
}
unsafe extern "C" {
    pub fn acos(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn asin(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn atan(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn atan2(_Y: f64, _X: f64) -> f64;
}
unsafe extern "C" {
    pub fn cos(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn cosh(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn exp(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn fabs(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn fmod(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn log(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn log10(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn pow(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn sin(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn sinh(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn sqrt(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn tan(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn tanh(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn acosh(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn asinh(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn atanh(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn atof(_String: *const ::core::ffi::c_char) -> f64;
}
unsafe extern "C" {
    pub fn _atof_l(_String: *const ::core::ffi::c_char, _Locale: _locale_t) -> f64;
}
unsafe extern "C" {
    pub fn _cabs(_Complex_value: _complex) -> f64;
}
unsafe extern "C" {
    pub fn cbrt(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn ceil(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn _chgsign(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn copysign(_Number: f64, _Sign: f64) -> f64;
}
unsafe extern "C" {
    pub fn _copysign(_Number: f64, _Sign: f64) -> f64;
}
unsafe extern "C" {
    pub fn erf(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn erfc(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn exp2(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn expm1(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn fdim(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn floor(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn fma(_X: f64, _Y: f64, _Z: f64) -> f64;
}
unsafe extern "C" {
    pub fn fmax(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn fmin(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn frexp(_X: f64, _Y: *mut ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn hypot(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn _hypot(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn ilogb(_X: f64) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn ldexp(_X: f64, _Y: ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn lgamma(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn llrint(_X: f64) -> ::core::ffi::c_longlong;
}
unsafe extern "C" {
    pub fn llround(_X: f64) -> ::core::ffi::c_longlong;
}
unsafe extern "C" {
    pub fn log1p(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn log2(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn logb(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn lrint(_X: f64) -> ::core::ffi::c_long;
}
unsafe extern "C" {
    pub fn lround(_X: f64) -> ::core::ffi::c_long;
}
unsafe extern "C" {
    pub fn _matherr(_Except: *mut _exception) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn modf(_X: f64, _Y: *mut f64) -> f64;
}
unsafe extern "C" {
    pub fn nan(_X: *const ::core::ffi::c_char) -> f64;
}
unsafe extern "C" {
    pub fn nearbyint(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn nextafter(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn nexttoward(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn remainder(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn remquo(_X: f64, _Y: f64, _Z: *mut ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn rint(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn round(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn scalbln(_X: f64, _Y: ::core::ffi::c_long) -> f64;
}
unsafe extern "C" {
    pub fn scalbn(_X: f64, _Y: ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn tgamma(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn trunc(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn _j0(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn _j1(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn _jn(_X: ::core::ffi::c_int, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn _y0(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn _y1(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn _yn(_X: ::core::ffi::c_int, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn acoshf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn asinhf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn atanhf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn cbrtf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn _chgsignf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn copysignf(_Number: f32, _Sign: f32) -> f32;
}
unsafe extern "C" {
    pub fn _copysignf(_Number: f32, _Sign: f32) -> f32;
}
unsafe extern "C" {
    pub fn erff(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn erfcf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn expm1f(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn exp2f(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn fdimf(_X: f32, _Y: f32) -> f32;
}
unsafe extern "C" {
    pub fn fmaf(_X: f32, _Y: f32, _Z: f32) -> f32;
}
unsafe extern "C" {
    pub fn fmaxf(_X: f32, _Y: f32) -> f32;
}
unsafe extern "C" {
    pub fn fminf(_X: f32, _Y: f32) -> f32;
}
unsafe extern "C" {
    pub fn _hypotf(_X: f32, _Y: f32) -> f32;
}
unsafe extern "C" {
    pub fn ilogbf(_X: f32) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn lgammaf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn llrintf(_X: f32) -> ::core::ffi::c_longlong;
}
unsafe extern "C" {
    pub fn llroundf(_X: f32) -> ::core::ffi::c_longlong;
}
unsafe extern "C" {
    pub fn log1pf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn log2f(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn logbf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn lrintf(_X: f32) -> ::core::ffi::c_long;
}
unsafe extern "C" {
    pub fn lroundf(_X: f32) -> ::core::ffi::c_long;
}
unsafe extern "C" {
    pub fn nanf(_X: *const ::core::ffi::c_char) -> f32;
}
unsafe extern "C" {
    pub fn nearbyintf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn nextafterf(_X: f32, _Y: f32) -> f32;
}
unsafe extern "C" {
    pub fn nexttowardf(_X: f32, _Y: f64) -> f32;
}
unsafe extern "C" {
    pub fn remainderf(_X: f32, _Y: f32) -> f32;
}
unsafe extern "C" {
    pub fn remquof(_X: f32, _Y: f32, _Z: *mut ::core::ffi::c_int) -> f32;
}
unsafe extern "C" {
    pub fn rintf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn roundf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn scalblnf(_X: f32, _Y: ::core::ffi::c_long) -> f32;
}
unsafe extern "C" {
    pub fn scalbnf(_X: f32, _Y: ::core::ffi::c_int) -> f32;
}
unsafe extern "C" {
    pub fn tgammaf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn truncf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn _logbf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn _nextafterf(_X: f32, _Y: f32) -> f32;
}
unsafe extern "C" {
    pub fn _finitef(_X: f32) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _isnanf(_X: f32) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _fpclassf(_X: f32) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _set_FMA3_enable(_Flag: ::core::ffi::c_int) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn _get_FMA3_enable() -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn acosf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn asinf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn atan2f(_Y: f32, _X: f32) -> f32;
}
unsafe extern "C" {
    pub fn atanf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn ceilf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn cosf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn coshf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn expf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn floorf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn fmodf(_X: f32, _Y: f32) -> f32;
}
unsafe extern "C" {
    pub fn log10f(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn logf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn modff(_X: f32, _Y: *mut f32) -> f32;
}
unsafe extern "C" {
    pub fn powf(_X: f32, _Y: f32) -> f32;
}
unsafe extern "C" {
    pub fn sinf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn sinhf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn sqrtf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn tanf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn tanhf(_X: f32) -> f32;
}
unsafe extern "C" {
    pub fn acoshl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn asinhl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn atanhl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn cbrtl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn copysignl(_Number: f64, _Sign: f64) -> f64;
}
unsafe extern "C" {
    pub fn erfl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn erfcl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn exp2l(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn expm1l(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn fdiml(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn fmal(_X: f64, _Y: f64, _Z: f64) -> f64;
}
unsafe extern "C" {
    pub fn fmaxl(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn fminl(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn ilogbl(_X: f64) -> ::core::ffi::c_int;
}
unsafe extern "C" {
    pub fn lgammal(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn llrintl(_X: f64) -> ::core::ffi::c_longlong;
}
unsafe extern "C" {
    pub fn llroundl(_X: f64) -> ::core::ffi::c_longlong;
}
unsafe extern "C" {
    pub fn log1pl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn log2l(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn logbl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn lrintl(_X: f64) -> ::core::ffi::c_long;
}
unsafe extern "C" {
    pub fn lroundl(_X: f64) -> ::core::ffi::c_long;
}
unsafe extern "C" {
    pub fn nanl(_X: *const ::core::ffi::c_char) -> f64;
}
unsafe extern "C" {
    pub fn nearbyintl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn nextafterl(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn nexttowardl(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn remainderl(_X: f64, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn remquol(_X: f64, _Y: f64, _Z: *mut ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn rintl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn roundl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn scalblnl(_X: f64, _Y: ::core::ffi::c_long) -> f64;
}
unsafe extern "C" {
    pub fn scalbnl(_X: f64, _Y: ::core::ffi::c_int) -> f64;
}
unsafe extern "C" {
    pub fn tgammal(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn truncl(_X: f64) -> f64;
}
unsafe extern "C" {
    pub static mut HUGE: f64;
}
unsafe extern "C" {
    pub fn j0(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn j1(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn jn(_X: ::core::ffi::c_int, _Y: f64) -> f64;
}
unsafe extern "C" {
    pub fn y0(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn y1(_X: f64) -> f64;
}
unsafe extern "C" {
    pub fn yn(_X: ::core::ffi::c_int, _Y: f64) -> f64;
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUStringView {
    pub data: *const ::core::ffi::c_char,
    pub length: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUStringView"][::core::mem::size_of::<WGPUStringView>() - 16usize];
    ["Alignment of WGPUStringView"][::core::mem::align_of::<WGPUStringView>() - 8usize];
    ["Offset of field: WGPUStringView::data"]
        [::core::mem::offset_of!(WGPUStringView, data) - 0usize];
    ["Offset of field: WGPUStringView::length"]
        [::core::mem::offset_of!(WGPUStringView, length) - 8usize];
};
impl Default for WGPUStringView {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type WGPUFlags = u64;
pub type WGPUBool = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUAdapterImpl {
    _unused: [u8; 0],
}
pub type WGPUAdapter = *mut WGPUAdapterImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUBindGroupImpl {
    _unused: [u8; 0],
}
pub type WGPUBindGroup = *mut WGPUBindGroupImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUBindGroupLayoutImpl {
    _unused: [u8; 0],
}
pub type WGPUBindGroupLayout = *mut WGPUBindGroupLayoutImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUBufferImpl {
    _unused: [u8; 0],
}
pub type WGPUBuffer = *mut WGPUBufferImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUCommandBufferImpl {
    _unused: [u8; 0],
}
pub type WGPUCommandBuffer = *mut WGPUCommandBufferImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUCommandEncoderImpl {
    _unused: [u8; 0],
}
pub type WGPUCommandEncoder = *mut WGPUCommandEncoderImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUComputePassEncoderImpl {
    _unused: [u8; 0],
}
pub type WGPUComputePassEncoder = *mut WGPUComputePassEncoderImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUComputePipelineImpl {
    _unused: [u8; 0],
}
pub type WGPUComputePipeline = *mut WGPUComputePipelineImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUDeviceImpl {
    _unused: [u8; 0],
}
pub type WGPUDevice = *mut WGPUDeviceImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUExternalTextureImpl {
    _unused: [u8; 0],
}
pub type WGPUExternalTexture = *mut WGPUExternalTextureImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUInstanceImpl {
    _unused: [u8; 0],
}
pub type WGPUInstance = *mut WGPUInstanceImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUPipelineLayoutImpl {
    _unused: [u8; 0],
}
pub type WGPUPipelineLayout = *mut WGPUPipelineLayoutImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUQuerySetImpl {
    _unused: [u8; 0],
}
pub type WGPUQuerySet = *mut WGPUQuerySetImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUQueueImpl {
    _unused: [u8; 0],
}
pub type WGPUQueue = *mut WGPUQueueImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPURenderBundleImpl {
    _unused: [u8; 0],
}
pub type WGPURenderBundle = *mut WGPURenderBundleImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPURenderBundleEncoderImpl {
    _unused: [u8; 0],
}
pub type WGPURenderBundleEncoder = *mut WGPURenderBundleEncoderImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPURenderPassEncoderImpl {
    _unused: [u8; 0],
}
pub type WGPURenderPassEncoder = *mut WGPURenderPassEncoderImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPURenderPipelineImpl {
    _unused: [u8; 0],
}
pub type WGPURenderPipeline = *mut WGPURenderPipelineImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUSamplerImpl {
    _unused: [u8; 0],
}
pub type WGPUSampler = *mut WGPUSamplerImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUShaderModuleImpl {
    _unused: [u8; 0],
}
pub type WGPUShaderModule = *mut WGPUShaderModuleImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUSharedBufferMemoryImpl {
    _unused: [u8; 0],
}
pub type WGPUSharedBufferMemory = *mut WGPUSharedBufferMemoryImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUSharedFenceImpl {
    _unused: [u8; 0],
}
pub type WGPUSharedFence = *mut WGPUSharedFenceImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUSharedTextureMemoryImpl {
    _unused: [u8; 0],
}
pub type WGPUSharedTextureMemory = *mut WGPUSharedTextureMemoryImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUSurfaceImpl {
    _unused: [u8; 0],
}
pub type WGPUSurface = *mut WGPUSurfaceImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUTextureImpl {
    _unused: [u8; 0],
}
pub type WGPUTexture = *mut WGPUTextureImpl;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct WGPUTextureViewImpl {
    _unused: [u8; 0],
}
pub type WGPUTextureView = *mut WGPUTextureViewImpl;
pub const WGPUAdapterType_WGPUAdapterType_DiscreteGPU: WGPUAdapterType = WGPUAdapterType(1);
pub const WGPUAdapterType_WGPUAdapterType_IntegratedGPU: WGPUAdapterType = WGPUAdapterType(2);
pub const WGPUAdapterType_WGPUAdapterType_CPU: WGPUAdapterType = WGPUAdapterType(3);
pub const WGPUAdapterType_WGPUAdapterType_Unknown: WGPUAdapterType = WGPUAdapterType(4);
pub const WGPUAdapterType_WGPUAdapterType_Force32: WGPUAdapterType = WGPUAdapterType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAdapterType(pub ::core::ffi::c_int);
pub const WGPUAddressMode_WGPUAddressMode_Undefined: WGPUAddressMode = WGPUAddressMode(0);
pub const WGPUAddressMode_WGPUAddressMode_ClampToEdge: WGPUAddressMode = WGPUAddressMode(1);
pub const WGPUAddressMode_WGPUAddressMode_Repeat: WGPUAddressMode = WGPUAddressMode(2);
pub const WGPUAddressMode_WGPUAddressMode_MirrorRepeat: WGPUAddressMode = WGPUAddressMode(3);
pub const WGPUAddressMode_WGPUAddressMode_Force32: WGPUAddressMode = WGPUAddressMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAddressMode(pub ::core::ffi::c_int);
pub const WGPUAlphaMode_WGPUAlphaMode_Opaque: WGPUAlphaMode = WGPUAlphaMode(1);
pub const WGPUAlphaMode_WGPUAlphaMode_Premultiplied: WGPUAlphaMode = WGPUAlphaMode(2);
pub const WGPUAlphaMode_WGPUAlphaMode_Unpremultiplied: WGPUAlphaMode = WGPUAlphaMode(3);
pub const WGPUAlphaMode_WGPUAlphaMode_Force32: WGPUAlphaMode = WGPUAlphaMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAlphaMode(pub ::core::ffi::c_int);
pub const WGPUBackendType_WGPUBackendType_Undefined: WGPUBackendType = WGPUBackendType(0);
pub const WGPUBackendType_WGPUBackendType_Null: WGPUBackendType = WGPUBackendType(1);
pub const WGPUBackendType_WGPUBackendType_WebGPU: WGPUBackendType = WGPUBackendType(2);
pub const WGPUBackendType_WGPUBackendType_D3D11: WGPUBackendType = WGPUBackendType(3);
pub const WGPUBackendType_WGPUBackendType_D3D12: WGPUBackendType = WGPUBackendType(4);
pub const WGPUBackendType_WGPUBackendType_Metal: WGPUBackendType = WGPUBackendType(5);
pub const WGPUBackendType_WGPUBackendType_Vulkan: WGPUBackendType = WGPUBackendType(6);
pub const WGPUBackendType_WGPUBackendType_OpenGL: WGPUBackendType = WGPUBackendType(7);
pub const WGPUBackendType_WGPUBackendType_OpenGLES: WGPUBackendType = WGPUBackendType(8);
pub const WGPUBackendType_WGPUBackendType_Force32: WGPUBackendType = WGPUBackendType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBackendType(pub ::core::ffi::c_int);
pub const WGPUBlendFactor_WGPUBlendFactor_Undefined: WGPUBlendFactor = WGPUBlendFactor(0);
pub const WGPUBlendFactor_WGPUBlendFactor_Zero: WGPUBlendFactor = WGPUBlendFactor(1);
pub const WGPUBlendFactor_WGPUBlendFactor_One: WGPUBlendFactor = WGPUBlendFactor(2);
pub const WGPUBlendFactor_WGPUBlendFactor_Src: WGPUBlendFactor = WGPUBlendFactor(3);
pub const WGPUBlendFactor_WGPUBlendFactor_OneMinusSrc: WGPUBlendFactor = WGPUBlendFactor(4);
pub const WGPUBlendFactor_WGPUBlendFactor_SrcAlpha: WGPUBlendFactor = WGPUBlendFactor(5);
pub const WGPUBlendFactor_WGPUBlendFactor_OneMinusSrcAlpha: WGPUBlendFactor = WGPUBlendFactor(6);
pub const WGPUBlendFactor_WGPUBlendFactor_Dst: WGPUBlendFactor = WGPUBlendFactor(7);
pub const WGPUBlendFactor_WGPUBlendFactor_OneMinusDst: WGPUBlendFactor = WGPUBlendFactor(8);
pub const WGPUBlendFactor_WGPUBlendFactor_DstAlpha: WGPUBlendFactor = WGPUBlendFactor(9);
pub const WGPUBlendFactor_WGPUBlendFactor_OneMinusDstAlpha: WGPUBlendFactor = WGPUBlendFactor(10);
pub const WGPUBlendFactor_WGPUBlendFactor_SrcAlphaSaturated: WGPUBlendFactor = WGPUBlendFactor(11);
pub const WGPUBlendFactor_WGPUBlendFactor_Constant: WGPUBlendFactor = WGPUBlendFactor(12);
pub const WGPUBlendFactor_WGPUBlendFactor_OneMinusConstant: WGPUBlendFactor = WGPUBlendFactor(13);
pub const WGPUBlendFactor_WGPUBlendFactor_Src1: WGPUBlendFactor = WGPUBlendFactor(14);
pub const WGPUBlendFactor_WGPUBlendFactor_OneMinusSrc1: WGPUBlendFactor = WGPUBlendFactor(15);
pub const WGPUBlendFactor_WGPUBlendFactor_Src1Alpha: WGPUBlendFactor = WGPUBlendFactor(16);
pub const WGPUBlendFactor_WGPUBlendFactor_OneMinusSrc1Alpha: WGPUBlendFactor = WGPUBlendFactor(17);
pub const WGPUBlendFactor_WGPUBlendFactor_Force32: WGPUBlendFactor = WGPUBlendFactor(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBlendFactor(pub ::core::ffi::c_int);
pub const WGPUBlendOperation_WGPUBlendOperation_Undefined: WGPUBlendOperation =
    WGPUBlendOperation(0);
pub const WGPUBlendOperation_WGPUBlendOperation_Add: WGPUBlendOperation = WGPUBlendOperation(1);
pub const WGPUBlendOperation_WGPUBlendOperation_Subtract: WGPUBlendOperation =
    WGPUBlendOperation(2);
pub const WGPUBlendOperation_WGPUBlendOperation_ReverseSubtract: WGPUBlendOperation =
    WGPUBlendOperation(3);
pub const WGPUBlendOperation_WGPUBlendOperation_Min: WGPUBlendOperation = WGPUBlendOperation(4);
pub const WGPUBlendOperation_WGPUBlendOperation_Max: WGPUBlendOperation = WGPUBlendOperation(5);
pub const WGPUBlendOperation_WGPUBlendOperation_Force32: WGPUBlendOperation =
    WGPUBlendOperation(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBlendOperation(pub ::core::ffi::c_int);
pub const WGPUBufferBindingType_WGPUBufferBindingType_BindingNotUsed: WGPUBufferBindingType =
    WGPUBufferBindingType(0);
pub const WGPUBufferBindingType_WGPUBufferBindingType_Undefined: WGPUBufferBindingType =
    WGPUBufferBindingType(1);
pub const WGPUBufferBindingType_WGPUBufferBindingType_Uniform: WGPUBufferBindingType =
    WGPUBufferBindingType(2);
pub const WGPUBufferBindingType_WGPUBufferBindingType_Storage: WGPUBufferBindingType =
    WGPUBufferBindingType(3);
pub const WGPUBufferBindingType_WGPUBufferBindingType_ReadOnlyStorage: WGPUBufferBindingType =
    WGPUBufferBindingType(4);
pub const WGPUBufferBindingType_WGPUBufferBindingType_Force32: WGPUBufferBindingType =
    WGPUBufferBindingType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBufferBindingType(pub ::core::ffi::c_int);
pub const WGPUBufferMapState_WGPUBufferMapState_Unmapped: WGPUBufferMapState =
    WGPUBufferMapState(1);
pub const WGPUBufferMapState_WGPUBufferMapState_Pending: WGPUBufferMapState = WGPUBufferMapState(2);
pub const WGPUBufferMapState_WGPUBufferMapState_Mapped: WGPUBufferMapState = WGPUBufferMapState(3);
pub const WGPUBufferMapState_WGPUBufferMapState_Force32: WGPUBufferMapState =
    WGPUBufferMapState(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBufferMapState(pub ::core::ffi::c_int);
pub const WGPUCallbackMode_WGPUCallbackMode_WaitAnyOnly: WGPUCallbackMode = WGPUCallbackMode(1);
pub const WGPUCallbackMode_WGPUCallbackMode_AllowProcessEvents: WGPUCallbackMode =
    WGPUCallbackMode(2);
pub const WGPUCallbackMode_WGPUCallbackMode_AllowSpontaneous: WGPUCallbackMode =
    WGPUCallbackMode(3);
pub const WGPUCallbackMode_WGPUCallbackMode_Force32: WGPUCallbackMode =
    WGPUCallbackMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCallbackMode(pub ::core::ffi::c_int);
pub const WGPUCompareFunction_WGPUCompareFunction_Undefined: WGPUCompareFunction =
    WGPUCompareFunction(0);
pub const WGPUCompareFunction_WGPUCompareFunction_Never: WGPUCompareFunction =
    WGPUCompareFunction(1);
pub const WGPUCompareFunction_WGPUCompareFunction_Less: WGPUCompareFunction =
    WGPUCompareFunction(2);
pub const WGPUCompareFunction_WGPUCompareFunction_Equal: WGPUCompareFunction =
    WGPUCompareFunction(3);
pub const WGPUCompareFunction_WGPUCompareFunction_LessEqual: WGPUCompareFunction =
    WGPUCompareFunction(4);
pub const WGPUCompareFunction_WGPUCompareFunction_Greater: WGPUCompareFunction =
    WGPUCompareFunction(5);
pub const WGPUCompareFunction_WGPUCompareFunction_NotEqual: WGPUCompareFunction =
    WGPUCompareFunction(6);
pub const WGPUCompareFunction_WGPUCompareFunction_GreaterEqual: WGPUCompareFunction =
    WGPUCompareFunction(7);
pub const WGPUCompareFunction_WGPUCompareFunction_Always: WGPUCompareFunction =
    WGPUCompareFunction(8);
pub const WGPUCompareFunction_WGPUCompareFunction_Force32: WGPUCompareFunction =
    WGPUCompareFunction(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCompareFunction(pub ::core::ffi::c_int);
pub const WGPUCompilationInfoRequestStatus_WGPUCompilationInfoRequestStatus_Success:
    WGPUCompilationInfoRequestStatus = WGPUCompilationInfoRequestStatus(1);
pub const WGPUCompilationInfoRequestStatus_WGPUCompilationInfoRequestStatus_CallbackCancelled:
    WGPUCompilationInfoRequestStatus = WGPUCompilationInfoRequestStatus(2);
pub const WGPUCompilationInfoRequestStatus_WGPUCompilationInfoRequestStatus_Force32:
    WGPUCompilationInfoRequestStatus = WGPUCompilationInfoRequestStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCompilationInfoRequestStatus(pub ::core::ffi::c_int);
pub const WGPUCompilationMessageType_WGPUCompilationMessageType_Error: WGPUCompilationMessageType =
    WGPUCompilationMessageType(1);
pub const WGPUCompilationMessageType_WGPUCompilationMessageType_Warning:
    WGPUCompilationMessageType = WGPUCompilationMessageType(2);
pub const WGPUCompilationMessageType_WGPUCompilationMessageType_Info: WGPUCompilationMessageType =
    WGPUCompilationMessageType(3);
pub const WGPUCompilationMessageType_WGPUCompilationMessageType_Force32:
    WGPUCompilationMessageType = WGPUCompilationMessageType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCompilationMessageType(pub ::core::ffi::c_int);
pub const WGPUCompositeAlphaMode_WGPUCompositeAlphaMode_Auto: WGPUCompositeAlphaMode =
    WGPUCompositeAlphaMode(0);
pub const WGPUCompositeAlphaMode_WGPUCompositeAlphaMode_Opaque: WGPUCompositeAlphaMode =
    WGPUCompositeAlphaMode(1);
pub const WGPUCompositeAlphaMode_WGPUCompositeAlphaMode_Premultiplied: WGPUCompositeAlphaMode =
    WGPUCompositeAlphaMode(2);
pub const WGPUCompositeAlphaMode_WGPUCompositeAlphaMode_Unpremultiplied: WGPUCompositeAlphaMode =
    WGPUCompositeAlphaMode(3);
pub const WGPUCompositeAlphaMode_WGPUCompositeAlphaMode_Inherit: WGPUCompositeAlphaMode =
    WGPUCompositeAlphaMode(4);
pub const WGPUCompositeAlphaMode_WGPUCompositeAlphaMode_Force32: WGPUCompositeAlphaMode =
    WGPUCompositeAlphaMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCompositeAlphaMode(pub ::core::ffi::c_int);
pub const WGPUCreatePipelineAsyncStatus_WGPUCreatePipelineAsyncStatus_Success:
    WGPUCreatePipelineAsyncStatus = WGPUCreatePipelineAsyncStatus(1);
pub const WGPUCreatePipelineAsyncStatus_WGPUCreatePipelineAsyncStatus_CallbackCancelled:
    WGPUCreatePipelineAsyncStatus = WGPUCreatePipelineAsyncStatus(2);
pub const WGPUCreatePipelineAsyncStatus_WGPUCreatePipelineAsyncStatus_ValidationError:
    WGPUCreatePipelineAsyncStatus = WGPUCreatePipelineAsyncStatus(3);
pub const WGPUCreatePipelineAsyncStatus_WGPUCreatePipelineAsyncStatus_InternalError:
    WGPUCreatePipelineAsyncStatus = WGPUCreatePipelineAsyncStatus(4);
pub const WGPUCreatePipelineAsyncStatus_WGPUCreatePipelineAsyncStatus_Force32:
    WGPUCreatePipelineAsyncStatus = WGPUCreatePipelineAsyncStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCreatePipelineAsyncStatus(pub ::core::ffi::c_int);
pub const WGPUCullMode_WGPUCullMode_Undefined: WGPUCullMode = WGPUCullMode(0);
pub const WGPUCullMode_WGPUCullMode_None: WGPUCullMode = WGPUCullMode(1);
pub const WGPUCullMode_WGPUCullMode_Front: WGPUCullMode = WGPUCullMode(2);
pub const WGPUCullMode_WGPUCullMode_Back: WGPUCullMode = WGPUCullMode(3);
pub const WGPUCullMode_WGPUCullMode_Force32: WGPUCullMode = WGPUCullMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCullMode(pub ::core::ffi::c_int);
pub const WGPUDeviceLostReason_WGPUDeviceLostReason_Unknown: WGPUDeviceLostReason =
    WGPUDeviceLostReason(1);
pub const WGPUDeviceLostReason_WGPUDeviceLostReason_Destroyed: WGPUDeviceLostReason =
    WGPUDeviceLostReason(2);
pub const WGPUDeviceLostReason_WGPUDeviceLostReason_CallbackCancelled: WGPUDeviceLostReason =
    WGPUDeviceLostReason(3);
pub const WGPUDeviceLostReason_WGPUDeviceLostReason_FailedCreation: WGPUDeviceLostReason =
    WGPUDeviceLostReason(4);
pub const WGPUDeviceLostReason_WGPUDeviceLostReason_Force32: WGPUDeviceLostReason =
    WGPUDeviceLostReason(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDeviceLostReason(pub ::core::ffi::c_int);
pub const WGPUErrorFilter_WGPUErrorFilter_Validation: WGPUErrorFilter = WGPUErrorFilter(1);
pub const WGPUErrorFilter_WGPUErrorFilter_OutOfMemory: WGPUErrorFilter = WGPUErrorFilter(2);
pub const WGPUErrorFilter_WGPUErrorFilter_Internal: WGPUErrorFilter = WGPUErrorFilter(3);
pub const WGPUErrorFilter_WGPUErrorFilter_Force32: WGPUErrorFilter = WGPUErrorFilter(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUErrorFilter(pub ::core::ffi::c_int);
pub const WGPUErrorType_WGPUErrorType_NoError: WGPUErrorType = WGPUErrorType(1);
pub const WGPUErrorType_WGPUErrorType_Validation: WGPUErrorType = WGPUErrorType(2);
pub const WGPUErrorType_WGPUErrorType_OutOfMemory: WGPUErrorType = WGPUErrorType(3);
pub const WGPUErrorType_WGPUErrorType_Internal: WGPUErrorType = WGPUErrorType(4);
pub const WGPUErrorType_WGPUErrorType_Unknown: WGPUErrorType = WGPUErrorType(5);
pub const WGPUErrorType_WGPUErrorType_Force32: WGPUErrorType = WGPUErrorType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUErrorType(pub ::core::ffi::c_int);
pub const WGPUExternalTextureRotation_WGPUExternalTextureRotation_Rotate0Degrees:
    WGPUExternalTextureRotation = WGPUExternalTextureRotation(1);
pub const WGPUExternalTextureRotation_WGPUExternalTextureRotation_Rotate90Degrees:
    WGPUExternalTextureRotation = WGPUExternalTextureRotation(2);
pub const WGPUExternalTextureRotation_WGPUExternalTextureRotation_Rotate180Degrees:
    WGPUExternalTextureRotation = WGPUExternalTextureRotation(3);
pub const WGPUExternalTextureRotation_WGPUExternalTextureRotation_Rotate270Degrees:
    WGPUExternalTextureRotation = WGPUExternalTextureRotation(4);
pub const WGPUExternalTextureRotation_WGPUExternalTextureRotation_Force32:
    WGPUExternalTextureRotation = WGPUExternalTextureRotation(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUExternalTextureRotation(pub ::core::ffi::c_int);
pub const WGPUFeatureLevel_WGPUFeatureLevel_Undefined: WGPUFeatureLevel = WGPUFeatureLevel(0);
pub const WGPUFeatureLevel_WGPUFeatureLevel_Compatibility: WGPUFeatureLevel = WGPUFeatureLevel(1);
pub const WGPUFeatureLevel_WGPUFeatureLevel_Core: WGPUFeatureLevel = WGPUFeatureLevel(2);
pub const WGPUFeatureLevel_WGPUFeatureLevel_Force32: WGPUFeatureLevel =
    WGPUFeatureLevel(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUFeatureLevel(pub ::core::ffi::c_int);
pub const WGPUFeatureName_WGPUFeatureName_DepthClipControl: WGPUFeatureName = WGPUFeatureName(1);
pub const WGPUFeatureName_WGPUFeatureName_Depth32FloatStencil8: WGPUFeatureName =
    WGPUFeatureName(2);
pub const WGPUFeatureName_WGPUFeatureName_TimestampQuery: WGPUFeatureName = WGPUFeatureName(3);
pub const WGPUFeatureName_WGPUFeatureName_TextureCompressionBC: WGPUFeatureName =
    WGPUFeatureName(4);
pub const WGPUFeatureName_WGPUFeatureName_TextureCompressionBCSliced3D: WGPUFeatureName =
    WGPUFeatureName(5);
pub const WGPUFeatureName_WGPUFeatureName_TextureCompressionETC2: WGPUFeatureName =
    WGPUFeatureName(6);
pub const WGPUFeatureName_WGPUFeatureName_TextureCompressionASTC: WGPUFeatureName =
    WGPUFeatureName(7);
pub const WGPUFeatureName_WGPUFeatureName_TextureCompressionASTCSliced3D: WGPUFeatureName =
    WGPUFeatureName(8);
pub const WGPUFeatureName_WGPUFeatureName_IndirectFirstInstance: WGPUFeatureName =
    WGPUFeatureName(9);
pub const WGPUFeatureName_WGPUFeatureName_ShaderF16: WGPUFeatureName = WGPUFeatureName(10);
pub const WGPUFeatureName_WGPUFeatureName_RG11B10UfloatRenderable: WGPUFeatureName =
    WGPUFeatureName(11);
pub const WGPUFeatureName_WGPUFeatureName_BGRA8UnormStorage: WGPUFeatureName = WGPUFeatureName(12);
pub const WGPUFeatureName_WGPUFeatureName_Float32Filterable: WGPUFeatureName = WGPUFeatureName(13);
pub const WGPUFeatureName_WGPUFeatureName_Float32Blendable: WGPUFeatureName = WGPUFeatureName(14);
pub const WGPUFeatureName_WGPUFeatureName_ClipDistances: WGPUFeatureName = WGPUFeatureName(15);
pub const WGPUFeatureName_WGPUFeatureName_DualSourceBlending: WGPUFeatureName = WGPUFeatureName(16);
pub const WGPUFeatureName_WGPUFeatureName_Subgroups: WGPUFeatureName = WGPUFeatureName(17);
pub const WGPUFeatureName_WGPUFeatureName_CoreFeaturesAndLimits: WGPUFeatureName =
    WGPUFeatureName(18);
pub const WGPUFeatureName_WGPUFeatureName_DawnInternalUsages: WGPUFeatureName =
    WGPUFeatureName(327680);
pub const WGPUFeatureName_WGPUFeatureName_DawnMultiPlanarFormats: WGPUFeatureName =
    WGPUFeatureName(327681);
pub const WGPUFeatureName_WGPUFeatureName_DawnNative: WGPUFeatureName = WGPUFeatureName(327682);
pub const WGPUFeatureName_WGPUFeatureName_ChromiumExperimentalTimestampQueryInsidePasses:
    WGPUFeatureName = WGPUFeatureName(327683);
pub const WGPUFeatureName_WGPUFeatureName_ImplicitDeviceSynchronization: WGPUFeatureName =
    WGPUFeatureName(327684);
pub const WGPUFeatureName_WGPUFeatureName_TransientAttachments: WGPUFeatureName =
    WGPUFeatureName(327686);
pub const WGPUFeatureName_WGPUFeatureName_MSAARenderToSingleSampled: WGPUFeatureName =
    WGPUFeatureName(327687);
pub const WGPUFeatureName_WGPUFeatureName_D3D11MultithreadProtected: WGPUFeatureName =
    WGPUFeatureName(327688);
pub const WGPUFeatureName_WGPUFeatureName_ANGLETextureSharing: WGPUFeatureName =
    WGPUFeatureName(327689);
pub const WGPUFeatureName_WGPUFeatureName_PixelLocalStorageCoherent: WGPUFeatureName =
    WGPUFeatureName(327690);
pub const WGPUFeatureName_WGPUFeatureName_PixelLocalStorageNonCoherent: WGPUFeatureName =
    WGPUFeatureName(327691);
pub const WGPUFeatureName_WGPUFeatureName_Unorm16TextureFormats: WGPUFeatureName =
    WGPUFeatureName(327692);
pub const WGPUFeatureName_WGPUFeatureName_Snorm16TextureFormats: WGPUFeatureName =
    WGPUFeatureName(327693);
pub const WGPUFeatureName_WGPUFeatureName_MultiPlanarFormatExtendedUsages: WGPUFeatureName =
    WGPUFeatureName(327694);
pub const WGPUFeatureName_WGPUFeatureName_MultiPlanarFormatP010: WGPUFeatureName =
    WGPUFeatureName(327695);
pub const WGPUFeatureName_WGPUFeatureName_HostMappedPointer: WGPUFeatureName =
    WGPUFeatureName(327696);
pub const WGPUFeatureName_WGPUFeatureName_MultiPlanarRenderTargets: WGPUFeatureName =
    WGPUFeatureName(327697);
pub const WGPUFeatureName_WGPUFeatureName_MultiPlanarFormatNv12a: WGPUFeatureName =
    WGPUFeatureName(327698);
pub const WGPUFeatureName_WGPUFeatureName_FramebufferFetch: WGPUFeatureName =
    WGPUFeatureName(327699);
pub const WGPUFeatureName_WGPUFeatureName_BufferMapExtendedUsages: WGPUFeatureName =
    WGPUFeatureName(327700);
pub const WGPUFeatureName_WGPUFeatureName_AdapterPropertiesMemoryHeaps: WGPUFeatureName =
    WGPUFeatureName(327701);
pub const WGPUFeatureName_WGPUFeatureName_AdapterPropertiesD3D: WGPUFeatureName =
    WGPUFeatureName(327702);
pub const WGPUFeatureName_WGPUFeatureName_AdapterPropertiesVk: WGPUFeatureName =
    WGPUFeatureName(327703);
pub const WGPUFeatureName_WGPUFeatureName_R8UnormStorage: WGPUFeatureName = WGPUFeatureName(327704);
pub const WGPUFeatureName_WGPUFeatureName_DawnFormatCapabilities: WGPUFeatureName =
    WGPUFeatureName(327705);
pub const WGPUFeatureName_WGPUFeatureName_DawnDrmFormatCapabilities: WGPUFeatureName =
    WGPUFeatureName(327706);
pub const WGPUFeatureName_WGPUFeatureName_Norm16TextureFormats: WGPUFeatureName =
    WGPUFeatureName(327707);
pub const WGPUFeatureName_WGPUFeatureName_MultiPlanarFormatNv16: WGPUFeatureName =
    WGPUFeatureName(327708);
pub const WGPUFeatureName_WGPUFeatureName_MultiPlanarFormatNv24: WGPUFeatureName =
    WGPUFeatureName(327709);
pub const WGPUFeatureName_WGPUFeatureName_MultiPlanarFormatP210: WGPUFeatureName =
    WGPUFeatureName(327710);
pub const WGPUFeatureName_WGPUFeatureName_MultiPlanarFormatP410: WGPUFeatureName =
    WGPUFeatureName(327711);
pub const WGPUFeatureName_WGPUFeatureName_SharedTextureMemoryVkDedicatedAllocation:
    WGPUFeatureName = WGPUFeatureName(327712);
pub const WGPUFeatureName_WGPUFeatureName_SharedTextureMemoryAHardwareBuffer: WGPUFeatureName =
    WGPUFeatureName(327713);
pub const WGPUFeatureName_WGPUFeatureName_SharedTextureMemoryDmaBuf: WGPUFeatureName =
    WGPUFeatureName(327714);
pub const WGPUFeatureName_WGPUFeatureName_SharedTextureMemoryOpaqueFD: WGPUFeatureName =
    WGPUFeatureName(327715);
pub const WGPUFeatureName_WGPUFeatureName_SharedTextureMemoryZirconHandle: WGPUFeatureName =
    WGPUFeatureName(327716);
pub const WGPUFeatureName_WGPUFeatureName_SharedTextureMemoryDXGISharedHandle: WGPUFeatureName =
    WGPUFeatureName(327717);
pub const WGPUFeatureName_WGPUFeatureName_SharedTextureMemoryD3D11Texture2D: WGPUFeatureName =
    WGPUFeatureName(327718);
pub const WGPUFeatureName_WGPUFeatureName_SharedTextureMemoryIOSurface: WGPUFeatureName =
    WGPUFeatureName(327719);
pub const WGPUFeatureName_WGPUFeatureName_SharedTextureMemoryEGLImage: WGPUFeatureName =
    WGPUFeatureName(327720);
pub const WGPUFeatureName_WGPUFeatureName_SharedFenceVkSemaphoreOpaqueFD: WGPUFeatureName =
    WGPUFeatureName(327721);
pub const WGPUFeatureName_WGPUFeatureName_SharedFenceSyncFD: WGPUFeatureName =
    WGPUFeatureName(327722);
pub const WGPUFeatureName_WGPUFeatureName_SharedFenceVkSemaphoreZirconHandle: WGPUFeatureName =
    WGPUFeatureName(327723);
pub const WGPUFeatureName_WGPUFeatureName_SharedFenceDXGISharedHandle: WGPUFeatureName =
    WGPUFeatureName(327724);
pub const WGPUFeatureName_WGPUFeatureName_SharedFenceMTLSharedEvent: WGPUFeatureName =
    WGPUFeatureName(327725);
pub const WGPUFeatureName_WGPUFeatureName_SharedBufferMemoryD3D12Resource: WGPUFeatureName =
    WGPUFeatureName(327726);
pub const WGPUFeatureName_WGPUFeatureName_StaticSamplers: WGPUFeatureName = WGPUFeatureName(327727);
pub const WGPUFeatureName_WGPUFeatureName_YCbCrVulkanSamplers: WGPUFeatureName =
    WGPUFeatureName(327728);
pub const WGPUFeatureName_WGPUFeatureName_ShaderModuleCompilationOptions: WGPUFeatureName =
    WGPUFeatureName(327729);
pub const WGPUFeatureName_WGPUFeatureName_DawnLoadResolveTexture: WGPUFeatureName =
    WGPUFeatureName(327730);
pub const WGPUFeatureName_WGPUFeatureName_DawnPartialLoadResolveTexture: WGPUFeatureName =
    WGPUFeatureName(327731);
pub const WGPUFeatureName_WGPUFeatureName_MultiDrawIndirect: WGPUFeatureName =
    WGPUFeatureName(327732);
pub const WGPUFeatureName_WGPUFeatureName_DawnTexelCopyBufferRowAlignment: WGPUFeatureName =
    WGPUFeatureName(327733);
pub const WGPUFeatureName_WGPUFeatureName_FlexibleTextureViews: WGPUFeatureName =
    WGPUFeatureName(327734);
pub const WGPUFeatureName_WGPUFeatureName_ChromiumExperimentalSubgroupMatrix: WGPUFeatureName =
    WGPUFeatureName(327735);
pub const WGPUFeatureName_WGPUFeatureName_SharedFenceEGLSync: WGPUFeatureName =
    WGPUFeatureName(327736);
pub const WGPUFeatureName_WGPUFeatureName_DawnDeviceAllocatorControl: WGPUFeatureName =
    WGPUFeatureName(327737);
pub const WGPUFeatureName_WGPUFeatureName_Force32: WGPUFeatureName = WGPUFeatureName(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUFeatureName(pub ::core::ffi::c_int);
pub const WGPUFilterMode_WGPUFilterMode_Undefined: WGPUFilterMode = WGPUFilterMode(0);
pub const WGPUFilterMode_WGPUFilterMode_Nearest: WGPUFilterMode = WGPUFilterMode(1);
pub const WGPUFilterMode_WGPUFilterMode_Linear: WGPUFilterMode = WGPUFilterMode(2);
pub const WGPUFilterMode_WGPUFilterMode_Force32: WGPUFilterMode = WGPUFilterMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUFilterMode(pub ::core::ffi::c_int);
pub const WGPUFrontFace_WGPUFrontFace_Undefined: WGPUFrontFace = WGPUFrontFace(0);
pub const WGPUFrontFace_WGPUFrontFace_CCW: WGPUFrontFace = WGPUFrontFace(1);
pub const WGPUFrontFace_WGPUFrontFace_CW: WGPUFrontFace = WGPUFrontFace(2);
pub const WGPUFrontFace_WGPUFrontFace_Force32: WGPUFrontFace = WGPUFrontFace(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUFrontFace(pub ::core::ffi::c_int);
pub const WGPUIndexFormat_WGPUIndexFormat_Undefined: WGPUIndexFormat = WGPUIndexFormat(0);
pub const WGPUIndexFormat_WGPUIndexFormat_Uint16: WGPUIndexFormat = WGPUIndexFormat(1);
pub const WGPUIndexFormat_WGPUIndexFormat_Uint32: WGPUIndexFormat = WGPUIndexFormat(2);
pub const WGPUIndexFormat_WGPUIndexFormat_Force32: WGPUIndexFormat = WGPUIndexFormat(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUIndexFormat(pub ::core::ffi::c_int);
pub const WGPULoadOp_WGPULoadOp_Undefined: WGPULoadOp = WGPULoadOp(0);
pub const WGPULoadOp_WGPULoadOp_Load: WGPULoadOp = WGPULoadOp(1);
pub const WGPULoadOp_WGPULoadOp_Clear: WGPULoadOp = WGPULoadOp(2);
pub const WGPULoadOp_WGPULoadOp_ExpandResolveTexture: WGPULoadOp = WGPULoadOp(327683);
pub const WGPULoadOp_WGPULoadOp_Force32: WGPULoadOp = WGPULoadOp(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPULoadOp(pub ::core::ffi::c_int);
pub const WGPULoggingType_WGPULoggingType_Verbose: WGPULoggingType = WGPULoggingType(1);
pub const WGPULoggingType_WGPULoggingType_Info: WGPULoggingType = WGPULoggingType(2);
pub const WGPULoggingType_WGPULoggingType_Warning: WGPULoggingType = WGPULoggingType(3);
pub const WGPULoggingType_WGPULoggingType_Error: WGPULoggingType = WGPULoggingType(4);
pub const WGPULoggingType_WGPULoggingType_Force32: WGPULoggingType = WGPULoggingType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPULoggingType(pub ::core::ffi::c_int);
pub const WGPUMapAsyncStatus_WGPUMapAsyncStatus_Success: WGPUMapAsyncStatus = WGPUMapAsyncStatus(1);
pub const WGPUMapAsyncStatus_WGPUMapAsyncStatus_CallbackCancelled: WGPUMapAsyncStatus =
    WGPUMapAsyncStatus(2);
pub const WGPUMapAsyncStatus_WGPUMapAsyncStatus_Error: WGPUMapAsyncStatus = WGPUMapAsyncStatus(3);
pub const WGPUMapAsyncStatus_WGPUMapAsyncStatus_Aborted: WGPUMapAsyncStatus = WGPUMapAsyncStatus(4);
pub const WGPUMapAsyncStatus_WGPUMapAsyncStatus_Force32: WGPUMapAsyncStatus =
    WGPUMapAsyncStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUMapAsyncStatus(pub ::core::ffi::c_int);
pub const WGPUMipmapFilterMode_WGPUMipmapFilterMode_Undefined: WGPUMipmapFilterMode =
    WGPUMipmapFilterMode(0);
pub const WGPUMipmapFilterMode_WGPUMipmapFilterMode_Nearest: WGPUMipmapFilterMode =
    WGPUMipmapFilterMode(1);
pub const WGPUMipmapFilterMode_WGPUMipmapFilterMode_Linear: WGPUMipmapFilterMode =
    WGPUMipmapFilterMode(2);
pub const WGPUMipmapFilterMode_WGPUMipmapFilterMode_Force32: WGPUMipmapFilterMode =
    WGPUMipmapFilterMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUMipmapFilterMode(pub ::core::ffi::c_int);
pub const WGPUOptionalBool_WGPUOptionalBool_False: WGPUOptionalBool = WGPUOptionalBool(0);
pub const WGPUOptionalBool_WGPUOptionalBool_True: WGPUOptionalBool = WGPUOptionalBool(1);
pub const WGPUOptionalBool_WGPUOptionalBool_Undefined: WGPUOptionalBool = WGPUOptionalBool(2);
pub const WGPUOptionalBool_WGPUOptionalBool_Force32: WGPUOptionalBool =
    WGPUOptionalBool(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUOptionalBool(pub ::core::ffi::c_int);
pub const WGPUPopErrorScopeStatus_WGPUPopErrorScopeStatus_Success: WGPUPopErrorScopeStatus =
    WGPUPopErrorScopeStatus(1);
pub const WGPUPopErrorScopeStatus_WGPUPopErrorScopeStatus_CallbackCancelled:
    WGPUPopErrorScopeStatus = WGPUPopErrorScopeStatus(2);
pub const WGPUPopErrorScopeStatus_WGPUPopErrorScopeStatus_Error: WGPUPopErrorScopeStatus =
    WGPUPopErrorScopeStatus(3);
pub const WGPUPopErrorScopeStatus_WGPUPopErrorScopeStatus_Force32: WGPUPopErrorScopeStatus =
    WGPUPopErrorScopeStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPopErrorScopeStatus(pub ::core::ffi::c_int);
pub const WGPUPowerPreference_WGPUPowerPreference_Undefined: WGPUPowerPreference =
    WGPUPowerPreference(0);
pub const WGPUPowerPreference_WGPUPowerPreference_LowPower: WGPUPowerPreference =
    WGPUPowerPreference(1);
pub const WGPUPowerPreference_WGPUPowerPreference_HighPerformance: WGPUPowerPreference =
    WGPUPowerPreference(2);
pub const WGPUPowerPreference_WGPUPowerPreference_Force32: WGPUPowerPreference =
    WGPUPowerPreference(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPowerPreference(pub ::core::ffi::c_int);
pub const WGPUPredefinedColorSpace_WGPUPredefinedColorSpace_SRGB: WGPUPredefinedColorSpace =
    WGPUPredefinedColorSpace(1);
pub const WGPUPredefinedColorSpace_WGPUPredefinedColorSpace_DisplayP3: WGPUPredefinedColorSpace =
    WGPUPredefinedColorSpace(2);
pub const WGPUPredefinedColorSpace_WGPUPredefinedColorSpace_Force32: WGPUPredefinedColorSpace =
    WGPUPredefinedColorSpace(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPredefinedColorSpace(pub ::core::ffi::c_int);
pub const WGPUPresentMode_WGPUPresentMode_Undefined: WGPUPresentMode = WGPUPresentMode(0);
pub const WGPUPresentMode_WGPUPresentMode_Fifo: WGPUPresentMode = WGPUPresentMode(1);
pub const WGPUPresentMode_WGPUPresentMode_FifoRelaxed: WGPUPresentMode = WGPUPresentMode(2);
pub const WGPUPresentMode_WGPUPresentMode_Immediate: WGPUPresentMode = WGPUPresentMode(3);
pub const WGPUPresentMode_WGPUPresentMode_Mailbox: WGPUPresentMode = WGPUPresentMode(4);
pub const WGPUPresentMode_WGPUPresentMode_Force32: WGPUPresentMode = WGPUPresentMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPresentMode(pub ::core::ffi::c_int);
pub const WGPUPrimitiveTopology_WGPUPrimitiveTopology_Undefined: WGPUPrimitiveTopology =
    WGPUPrimitiveTopology(0);
pub const WGPUPrimitiveTopology_WGPUPrimitiveTopology_PointList: WGPUPrimitiveTopology =
    WGPUPrimitiveTopology(1);
pub const WGPUPrimitiveTopology_WGPUPrimitiveTopology_LineList: WGPUPrimitiveTopology =
    WGPUPrimitiveTopology(2);
pub const WGPUPrimitiveTopology_WGPUPrimitiveTopology_LineStrip: WGPUPrimitiveTopology =
    WGPUPrimitiveTopology(3);
pub const WGPUPrimitiveTopology_WGPUPrimitiveTopology_TriangleList: WGPUPrimitiveTopology =
    WGPUPrimitiveTopology(4);
pub const WGPUPrimitiveTopology_WGPUPrimitiveTopology_TriangleStrip: WGPUPrimitiveTopology =
    WGPUPrimitiveTopology(5);
pub const WGPUPrimitiveTopology_WGPUPrimitiveTopology_Force32: WGPUPrimitiveTopology =
    WGPUPrimitiveTopology(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPrimitiveTopology(pub ::core::ffi::c_int);
pub const WGPUQueryType_WGPUQueryType_Occlusion: WGPUQueryType = WGPUQueryType(1);
pub const WGPUQueryType_WGPUQueryType_Timestamp: WGPUQueryType = WGPUQueryType(2);
pub const WGPUQueryType_WGPUQueryType_Force32: WGPUQueryType = WGPUQueryType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUQueryType(pub ::core::ffi::c_int);
pub const WGPUQueueWorkDoneStatus_WGPUQueueWorkDoneStatus_Success: WGPUQueueWorkDoneStatus =
    WGPUQueueWorkDoneStatus(1);
pub const WGPUQueueWorkDoneStatus_WGPUQueueWorkDoneStatus_CallbackCancelled:
    WGPUQueueWorkDoneStatus = WGPUQueueWorkDoneStatus(2);
pub const WGPUQueueWorkDoneStatus_WGPUQueueWorkDoneStatus_Error: WGPUQueueWorkDoneStatus =
    WGPUQueueWorkDoneStatus(3);
pub const WGPUQueueWorkDoneStatus_WGPUQueueWorkDoneStatus_Force32: WGPUQueueWorkDoneStatus =
    WGPUQueueWorkDoneStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUQueueWorkDoneStatus(pub ::core::ffi::c_int);
pub const WGPURequestAdapterStatus_WGPURequestAdapterStatus_Success: WGPURequestAdapterStatus =
    WGPURequestAdapterStatus(1);
pub const WGPURequestAdapterStatus_WGPURequestAdapterStatus_CallbackCancelled:
    WGPURequestAdapterStatus = WGPURequestAdapterStatus(2);
pub const WGPURequestAdapterStatus_WGPURequestAdapterStatus_Unavailable: WGPURequestAdapterStatus =
    WGPURequestAdapterStatus(3);
pub const WGPURequestAdapterStatus_WGPURequestAdapterStatus_Error: WGPURequestAdapterStatus =
    WGPURequestAdapterStatus(4);
pub const WGPURequestAdapterStatus_WGPURequestAdapterStatus_Force32: WGPURequestAdapterStatus =
    WGPURequestAdapterStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURequestAdapterStatus(pub ::core::ffi::c_int);
pub const WGPURequestDeviceStatus_WGPURequestDeviceStatus_Success: WGPURequestDeviceStatus =
    WGPURequestDeviceStatus(1);
pub const WGPURequestDeviceStatus_WGPURequestDeviceStatus_CallbackCancelled:
    WGPURequestDeviceStatus = WGPURequestDeviceStatus(2);
pub const WGPURequestDeviceStatus_WGPURequestDeviceStatus_Error: WGPURequestDeviceStatus =
    WGPURequestDeviceStatus(3);
pub const WGPURequestDeviceStatus_WGPURequestDeviceStatus_Force32: WGPURequestDeviceStatus =
    WGPURequestDeviceStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURequestDeviceStatus(pub ::core::ffi::c_int);
pub const WGPUSamplerBindingType_WGPUSamplerBindingType_BindingNotUsed: WGPUSamplerBindingType =
    WGPUSamplerBindingType(0);
pub const WGPUSamplerBindingType_WGPUSamplerBindingType_Undefined: WGPUSamplerBindingType =
    WGPUSamplerBindingType(1);
pub const WGPUSamplerBindingType_WGPUSamplerBindingType_Filtering: WGPUSamplerBindingType =
    WGPUSamplerBindingType(2);
pub const WGPUSamplerBindingType_WGPUSamplerBindingType_NonFiltering: WGPUSamplerBindingType =
    WGPUSamplerBindingType(3);
pub const WGPUSamplerBindingType_WGPUSamplerBindingType_Comparison: WGPUSamplerBindingType =
    WGPUSamplerBindingType(4);
pub const WGPUSamplerBindingType_WGPUSamplerBindingType_Force32: WGPUSamplerBindingType =
    WGPUSamplerBindingType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSamplerBindingType(pub ::core::ffi::c_int);
pub const WGPUSharedFenceType_WGPUSharedFenceType_VkSemaphoreOpaqueFD: WGPUSharedFenceType =
    WGPUSharedFenceType(1);
pub const WGPUSharedFenceType_WGPUSharedFenceType_SyncFD: WGPUSharedFenceType =
    WGPUSharedFenceType(2);
pub const WGPUSharedFenceType_WGPUSharedFenceType_VkSemaphoreZirconHandle: WGPUSharedFenceType =
    WGPUSharedFenceType(3);
pub const WGPUSharedFenceType_WGPUSharedFenceType_DXGISharedHandle: WGPUSharedFenceType =
    WGPUSharedFenceType(4);
pub const WGPUSharedFenceType_WGPUSharedFenceType_MTLSharedEvent: WGPUSharedFenceType =
    WGPUSharedFenceType(5);
pub const WGPUSharedFenceType_WGPUSharedFenceType_EGLSync: WGPUSharedFenceType =
    WGPUSharedFenceType(6);
pub const WGPUSharedFenceType_WGPUSharedFenceType_Force32: WGPUSharedFenceType =
    WGPUSharedFenceType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceType(pub ::core::ffi::c_int);
pub const WGPUStatus_WGPUStatus_Success: WGPUStatus = WGPUStatus(1);
pub const WGPUStatus_WGPUStatus_Error: WGPUStatus = WGPUStatus(2);
pub const WGPUStatus_WGPUStatus_Force32: WGPUStatus = WGPUStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUStatus(pub ::core::ffi::c_int);
pub const WGPUStencilOperation_WGPUStencilOperation_Undefined: WGPUStencilOperation =
    WGPUStencilOperation(0);
pub const WGPUStencilOperation_WGPUStencilOperation_Keep: WGPUStencilOperation =
    WGPUStencilOperation(1);
pub const WGPUStencilOperation_WGPUStencilOperation_Zero: WGPUStencilOperation =
    WGPUStencilOperation(2);
pub const WGPUStencilOperation_WGPUStencilOperation_Replace: WGPUStencilOperation =
    WGPUStencilOperation(3);
pub const WGPUStencilOperation_WGPUStencilOperation_Invert: WGPUStencilOperation =
    WGPUStencilOperation(4);
pub const WGPUStencilOperation_WGPUStencilOperation_IncrementClamp: WGPUStencilOperation =
    WGPUStencilOperation(5);
pub const WGPUStencilOperation_WGPUStencilOperation_DecrementClamp: WGPUStencilOperation =
    WGPUStencilOperation(6);
pub const WGPUStencilOperation_WGPUStencilOperation_IncrementWrap: WGPUStencilOperation =
    WGPUStencilOperation(7);
pub const WGPUStencilOperation_WGPUStencilOperation_DecrementWrap: WGPUStencilOperation =
    WGPUStencilOperation(8);
pub const WGPUStencilOperation_WGPUStencilOperation_Force32: WGPUStencilOperation =
    WGPUStencilOperation(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUStencilOperation(pub ::core::ffi::c_int);
pub const WGPUStorageTextureAccess_WGPUStorageTextureAccess_BindingNotUsed:
    WGPUStorageTextureAccess = WGPUStorageTextureAccess(0);
pub const WGPUStorageTextureAccess_WGPUStorageTextureAccess_Undefined: WGPUStorageTextureAccess =
    WGPUStorageTextureAccess(1);
pub const WGPUStorageTextureAccess_WGPUStorageTextureAccess_WriteOnly: WGPUStorageTextureAccess =
    WGPUStorageTextureAccess(2);
pub const WGPUStorageTextureAccess_WGPUStorageTextureAccess_ReadOnly: WGPUStorageTextureAccess =
    WGPUStorageTextureAccess(3);
pub const WGPUStorageTextureAccess_WGPUStorageTextureAccess_ReadWrite: WGPUStorageTextureAccess =
    WGPUStorageTextureAccess(4);
pub const WGPUStorageTextureAccess_WGPUStorageTextureAccess_Force32: WGPUStorageTextureAccess =
    WGPUStorageTextureAccess(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUStorageTextureAccess(pub ::core::ffi::c_int);
pub const WGPUStoreOp_WGPUStoreOp_Undefined: WGPUStoreOp = WGPUStoreOp(0);
pub const WGPUStoreOp_WGPUStoreOp_Store: WGPUStoreOp = WGPUStoreOp(1);
pub const WGPUStoreOp_WGPUStoreOp_Discard: WGPUStoreOp = WGPUStoreOp(2);
pub const WGPUStoreOp_WGPUStoreOp_Force32: WGPUStoreOp = WGPUStoreOp(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUStoreOp(pub ::core::ffi::c_int);
pub const WGPUSType_WGPUSType_ShaderSourceSPIRV: WGPUSType = WGPUSType(1);
pub const WGPUSType_WGPUSType_ShaderSourceWGSL: WGPUSType = WGPUSType(2);
pub const WGPUSType_WGPUSType_RenderPassMaxDrawCount: WGPUSType = WGPUSType(3);
pub const WGPUSType_WGPUSType_SurfaceSourceMetalLayer: WGPUSType = WGPUSType(4);
pub const WGPUSType_WGPUSType_SurfaceSourceWindowsHWND: WGPUSType = WGPUSType(5);
pub const WGPUSType_WGPUSType_SurfaceSourceXlibWindow: WGPUSType = WGPUSType(6);
pub const WGPUSType_WGPUSType_SurfaceSourceWaylandSurface: WGPUSType = WGPUSType(7);
pub const WGPUSType_WGPUSType_SurfaceSourceAndroidNativeWindow: WGPUSType = WGPUSType(8);
pub const WGPUSType_WGPUSType_SurfaceSourceXCBWindow: WGPUSType = WGPUSType(9);
pub const WGPUSType_WGPUSType_SurfaceColorManagement: WGPUSType = WGPUSType(10);
pub const WGPUSType_WGPUSType_RequestAdapterWebXROptions: WGPUSType = WGPUSType(11);
pub const WGPUSType_WGPUSType_AdapterPropertiesSubgroups: WGPUSType = WGPUSType(12);
pub const WGPUSType_WGPUSType_BindGroupLayoutEntryArraySize: WGPUSType = WGPUSType(13);
pub const WGPUSType_WGPUSType_TextureBindingViewDimensionDescriptor: WGPUSType = WGPUSType(131072);
pub const WGPUSType_WGPUSType_EmscriptenSurfaceSourceCanvasHTMLSelector: WGPUSType =
    WGPUSType(262144);
pub const WGPUSType_WGPUSType_SurfaceDescriptorFromWindowsCoreWindow: WGPUSType = WGPUSType(327680);
pub const WGPUSType_WGPUSType_ExternalTextureBindingEntry: WGPUSType = WGPUSType(327681);
pub const WGPUSType_WGPUSType_ExternalTextureBindingLayout: WGPUSType = WGPUSType(327682);
pub const WGPUSType_WGPUSType_SurfaceDescriptorFromWindowsUWPSwapChainPanel: WGPUSType =
    WGPUSType(327683);
pub const WGPUSType_WGPUSType_DawnTextureInternalUsageDescriptor: WGPUSType = WGPUSType(327684);
pub const WGPUSType_WGPUSType_DawnEncoderInternalUsageDescriptor: WGPUSType = WGPUSType(327685);
pub const WGPUSType_WGPUSType_DawnInstanceDescriptor: WGPUSType = WGPUSType(327686);
pub const WGPUSType_WGPUSType_DawnCacheDeviceDescriptor: WGPUSType = WGPUSType(327687);
pub const WGPUSType_WGPUSType_DawnAdapterPropertiesPowerPreference: WGPUSType = WGPUSType(327688);
pub const WGPUSType_WGPUSType_DawnBufferDescriptorErrorInfoFromWireClient: WGPUSType =
    WGPUSType(327689);
pub const WGPUSType_WGPUSType_DawnTogglesDescriptor: WGPUSType = WGPUSType(327690);
pub const WGPUSType_WGPUSType_DawnShaderModuleSPIRVOptionsDescriptor: WGPUSType = WGPUSType(327691);
pub const WGPUSType_WGPUSType_RequestAdapterOptionsLUID: WGPUSType = WGPUSType(327692);
pub const WGPUSType_WGPUSType_RequestAdapterOptionsGetGLProc: WGPUSType = WGPUSType(327693);
pub const WGPUSType_WGPUSType_RequestAdapterOptionsD3D11Device: WGPUSType = WGPUSType(327694);
pub const WGPUSType_WGPUSType_DawnRenderPassColorAttachmentRenderToSingleSampled: WGPUSType =
    WGPUSType(327695);
pub const WGPUSType_WGPUSType_RenderPassPixelLocalStorage: WGPUSType = WGPUSType(327696);
pub const WGPUSType_WGPUSType_PipelineLayoutPixelLocalStorage: WGPUSType = WGPUSType(327697);
pub const WGPUSType_WGPUSType_BufferHostMappedPointer: WGPUSType = WGPUSType(327698);
pub const WGPUSType_WGPUSType_AdapterPropertiesMemoryHeaps: WGPUSType = WGPUSType(327699);
pub const WGPUSType_WGPUSType_AdapterPropertiesD3D: WGPUSType = WGPUSType(327700);
pub const WGPUSType_WGPUSType_AdapterPropertiesVk: WGPUSType = WGPUSType(327701);
pub const WGPUSType_WGPUSType_DawnWireWGSLControl: WGPUSType = WGPUSType(327702);
pub const WGPUSType_WGPUSType_DawnWGSLBlocklist: WGPUSType = WGPUSType(327703);
pub const WGPUSType_WGPUSType_DawnDrmFormatCapabilities: WGPUSType = WGPUSType(327704);
pub const WGPUSType_WGPUSType_ShaderModuleCompilationOptions: WGPUSType = WGPUSType(327705);
pub const WGPUSType_WGPUSType_ColorTargetStateExpandResolveTextureDawn: WGPUSType =
    WGPUSType(327706);
pub const WGPUSType_WGPUSType_RenderPassDescriptorExpandResolveRect: WGPUSType = WGPUSType(327707);
pub const WGPUSType_WGPUSType_SharedTextureMemoryVkDedicatedAllocationDescriptor: WGPUSType =
    WGPUSType(327708);
pub const WGPUSType_WGPUSType_SharedTextureMemoryAHardwareBufferDescriptor: WGPUSType =
    WGPUSType(327709);
pub const WGPUSType_WGPUSType_SharedTextureMemoryDmaBufDescriptor: WGPUSType = WGPUSType(327710);
pub const WGPUSType_WGPUSType_SharedTextureMemoryOpaqueFDDescriptor: WGPUSType = WGPUSType(327711);
pub const WGPUSType_WGPUSType_SharedTextureMemoryZirconHandleDescriptor: WGPUSType =
    WGPUSType(327712);
pub const WGPUSType_WGPUSType_SharedTextureMemoryDXGISharedHandleDescriptor: WGPUSType =
    WGPUSType(327713);
pub const WGPUSType_WGPUSType_SharedTextureMemoryD3D11Texture2DDescriptor: WGPUSType =
    WGPUSType(327714);
pub const WGPUSType_WGPUSType_SharedTextureMemoryIOSurfaceDescriptor: WGPUSType = WGPUSType(327715);
pub const WGPUSType_WGPUSType_SharedTextureMemoryEGLImageDescriptor: WGPUSType = WGPUSType(327716);
pub const WGPUSType_WGPUSType_SharedTextureMemoryInitializedBeginState: WGPUSType =
    WGPUSType(327717);
pub const WGPUSType_WGPUSType_SharedTextureMemoryInitializedEndState: WGPUSType = WGPUSType(327718);
pub const WGPUSType_WGPUSType_SharedTextureMemoryVkImageLayoutBeginState: WGPUSType =
    WGPUSType(327719);
pub const WGPUSType_WGPUSType_SharedTextureMemoryVkImageLayoutEndState: WGPUSType =
    WGPUSType(327720);
pub const WGPUSType_WGPUSType_SharedTextureMemoryD3DSwapchainBeginState: WGPUSType =
    WGPUSType(327721);
pub const WGPUSType_WGPUSType_SharedFenceVkSemaphoreOpaqueFDDescriptor: WGPUSType =
    WGPUSType(327722);
pub const WGPUSType_WGPUSType_SharedFenceVkSemaphoreOpaqueFDExportInfo: WGPUSType =
    WGPUSType(327723);
pub const WGPUSType_WGPUSType_SharedFenceSyncFDDescriptor: WGPUSType = WGPUSType(327724);
pub const WGPUSType_WGPUSType_SharedFenceSyncFDExportInfo: WGPUSType = WGPUSType(327725);
pub const WGPUSType_WGPUSType_SharedFenceVkSemaphoreZirconHandleDescriptor: WGPUSType =
    WGPUSType(327726);
pub const WGPUSType_WGPUSType_SharedFenceVkSemaphoreZirconHandleExportInfo: WGPUSType =
    WGPUSType(327727);
pub const WGPUSType_WGPUSType_SharedFenceDXGISharedHandleDescriptor: WGPUSType = WGPUSType(327728);
pub const WGPUSType_WGPUSType_SharedFenceDXGISharedHandleExportInfo: WGPUSType = WGPUSType(327729);
pub const WGPUSType_WGPUSType_SharedFenceMTLSharedEventDescriptor: WGPUSType = WGPUSType(327730);
pub const WGPUSType_WGPUSType_SharedFenceMTLSharedEventExportInfo: WGPUSType = WGPUSType(327731);
pub const WGPUSType_WGPUSType_SharedBufferMemoryD3D12ResourceDescriptor: WGPUSType =
    WGPUSType(327732);
pub const WGPUSType_WGPUSType_StaticSamplerBindingLayout: WGPUSType = WGPUSType(327733);
pub const WGPUSType_WGPUSType_YCbCrVkDescriptor: WGPUSType = WGPUSType(327734);
pub const WGPUSType_WGPUSType_SharedTextureMemoryAHardwareBufferProperties: WGPUSType =
    WGPUSType(327735);
pub const WGPUSType_WGPUSType_AHardwareBufferProperties: WGPUSType = WGPUSType(327736);
pub const WGPUSType_WGPUSType_DawnTexelCopyBufferRowAlignmentLimits: WGPUSType = WGPUSType(327738);
pub const WGPUSType_WGPUSType_AdapterPropertiesSubgroupMatrixConfigs: WGPUSType = WGPUSType(327739);
pub const WGPUSType_WGPUSType_SharedFenceEGLSyncDescriptor: WGPUSType = WGPUSType(327740);
pub const WGPUSType_WGPUSType_SharedFenceEGLSyncExportInfo: WGPUSType = WGPUSType(327741);
pub const WGPUSType_WGPUSType_DawnInjectedInvalidSType: WGPUSType = WGPUSType(327742);
pub const WGPUSType_WGPUSType_DawnCompilationMessageUtf16: WGPUSType = WGPUSType(327743);
pub const WGPUSType_WGPUSType_DawnFakeBufferOOMForTesting: WGPUSType = WGPUSType(327744);
pub const WGPUSType_WGPUSType_SurfaceDescriptorFromWindowsWinUISwapChainPanel: WGPUSType =
    WGPUSType(327745);
pub const WGPUSType_WGPUSType_DawnDeviceAllocatorControl: WGPUSType = WGPUSType(327746);
pub const WGPUSType_WGPUSType_DawnHostMappedPointerLimits: WGPUSType = WGPUSType(327747);
pub const WGPUSType_WGPUSType_RenderPassDescriptorResolveRect: WGPUSType = WGPUSType(327748);
pub const WGPUSType_WGPUSType_Force32: WGPUSType = WGPUSType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSType(pub ::core::ffi::c_int);
pub const WGPUSubgroupMatrixComponentType_WGPUSubgroupMatrixComponentType_F32:
    WGPUSubgroupMatrixComponentType = WGPUSubgroupMatrixComponentType(1);
pub const WGPUSubgroupMatrixComponentType_WGPUSubgroupMatrixComponentType_F16:
    WGPUSubgroupMatrixComponentType = WGPUSubgroupMatrixComponentType(2);
pub const WGPUSubgroupMatrixComponentType_WGPUSubgroupMatrixComponentType_U32:
    WGPUSubgroupMatrixComponentType = WGPUSubgroupMatrixComponentType(3);
pub const WGPUSubgroupMatrixComponentType_WGPUSubgroupMatrixComponentType_I32:
    WGPUSubgroupMatrixComponentType = WGPUSubgroupMatrixComponentType(4);
pub const WGPUSubgroupMatrixComponentType_WGPUSubgroupMatrixComponentType_Force32:
    WGPUSubgroupMatrixComponentType = WGPUSubgroupMatrixComponentType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSubgroupMatrixComponentType(pub ::core::ffi::c_int);
pub const WGPUSurfaceGetCurrentTextureStatus_WGPUSurfaceGetCurrentTextureStatus_SuccessOptimal:
    WGPUSurfaceGetCurrentTextureStatus = WGPUSurfaceGetCurrentTextureStatus(1);
pub const WGPUSurfaceGetCurrentTextureStatus_WGPUSurfaceGetCurrentTextureStatus_SuccessSuboptimal : WGPUSurfaceGetCurrentTextureStatus = WGPUSurfaceGetCurrentTextureStatus (2) ;
pub const WGPUSurfaceGetCurrentTextureStatus_WGPUSurfaceGetCurrentTextureStatus_Timeout:
    WGPUSurfaceGetCurrentTextureStatus = WGPUSurfaceGetCurrentTextureStatus(3);
pub const WGPUSurfaceGetCurrentTextureStatus_WGPUSurfaceGetCurrentTextureStatus_Outdated:
    WGPUSurfaceGetCurrentTextureStatus = WGPUSurfaceGetCurrentTextureStatus(4);
pub const WGPUSurfaceGetCurrentTextureStatus_WGPUSurfaceGetCurrentTextureStatus_Lost:
    WGPUSurfaceGetCurrentTextureStatus = WGPUSurfaceGetCurrentTextureStatus(5);
pub const WGPUSurfaceGetCurrentTextureStatus_WGPUSurfaceGetCurrentTextureStatus_Error:
    WGPUSurfaceGetCurrentTextureStatus = WGPUSurfaceGetCurrentTextureStatus(6);
pub const WGPUSurfaceGetCurrentTextureStatus_WGPUSurfaceGetCurrentTextureStatus_Force32:
    WGPUSurfaceGetCurrentTextureStatus = WGPUSurfaceGetCurrentTextureStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceGetCurrentTextureStatus(pub ::core::ffi::c_int);
pub const WGPUTextureAspect_WGPUTextureAspect_Undefined: WGPUTextureAspect = WGPUTextureAspect(0);
pub const WGPUTextureAspect_WGPUTextureAspect_All: WGPUTextureAspect = WGPUTextureAspect(1);
pub const WGPUTextureAspect_WGPUTextureAspect_StencilOnly: WGPUTextureAspect = WGPUTextureAspect(2);
pub const WGPUTextureAspect_WGPUTextureAspect_DepthOnly: WGPUTextureAspect = WGPUTextureAspect(3);
pub const WGPUTextureAspect_WGPUTextureAspect_Plane0Only: WGPUTextureAspect =
    WGPUTextureAspect(327680);
pub const WGPUTextureAspect_WGPUTextureAspect_Plane1Only: WGPUTextureAspect =
    WGPUTextureAspect(327681);
pub const WGPUTextureAspect_WGPUTextureAspect_Plane2Only: WGPUTextureAspect =
    WGPUTextureAspect(327682);
pub const WGPUTextureAspect_WGPUTextureAspect_Force32: WGPUTextureAspect =
    WGPUTextureAspect(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTextureAspect(pub ::core::ffi::c_int);
pub const WGPUTextureDimension_WGPUTextureDimension_Undefined: WGPUTextureDimension =
    WGPUTextureDimension(0);
pub const WGPUTextureDimension_WGPUTextureDimension_1D: WGPUTextureDimension =
    WGPUTextureDimension(1);
pub const WGPUTextureDimension_WGPUTextureDimension_2D: WGPUTextureDimension =
    WGPUTextureDimension(2);
pub const WGPUTextureDimension_WGPUTextureDimension_3D: WGPUTextureDimension =
    WGPUTextureDimension(3);
pub const WGPUTextureDimension_WGPUTextureDimension_Force32: WGPUTextureDimension =
    WGPUTextureDimension(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTextureDimension(pub ::core::ffi::c_int);
pub const WGPUTextureFormat_WGPUTextureFormat_Undefined: WGPUTextureFormat = WGPUTextureFormat(0);
pub const WGPUTextureFormat_WGPUTextureFormat_R8Unorm: WGPUTextureFormat = WGPUTextureFormat(1);
pub const WGPUTextureFormat_WGPUTextureFormat_R8Snorm: WGPUTextureFormat = WGPUTextureFormat(2);
pub const WGPUTextureFormat_WGPUTextureFormat_R8Uint: WGPUTextureFormat = WGPUTextureFormat(3);
pub const WGPUTextureFormat_WGPUTextureFormat_R8Sint: WGPUTextureFormat = WGPUTextureFormat(4);
pub const WGPUTextureFormat_WGPUTextureFormat_R16Uint: WGPUTextureFormat = WGPUTextureFormat(5);
pub const WGPUTextureFormat_WGPUTextureFormat_R16Sint: WGPUTextureFormat = WGPUTextureFormat(6);
pub const WGPUTextureFormat_WGPUTextureFormat_R16Float: WGPUTextureFormat = WGPUTextureFormat(7);
pub const WGPUTextureFormat_WGPUTextureFormat_RG8Unorm: WGPUTextureFormat = WGPUTextureFormat(8);
pub const WGPUTextureFormat_WGPUTextureFormat_RG8Snorm: WGPUTextureFormat = WGPUTextureFormat(9);
pub const WGPUTextureFormat_WGPUTextureFormat_RG8Uint: WGPUTextureFormat = WGPUTextureFormat(10);
pub const WGPUTextureFormat_WGPUTextureFormat_RG8Sint: WGPUTextureFormat = WGPUTextureFormat(11);
pub const WGPUTextureFormat_WGPUTextureFormat_R32Float: WGPUTextureFormat = WGPUTextureFormat(12);
pub const WGPUTextureFormat_WGPUTextureFormat_R32Uint: WGPUTextureFormat = WGPUTextureFormat(13);
pub const WGPUTextureFormat_WGPUTextureFormat_R32Sint: WGPUTextureFormat = WGPUTextureFormat(14);
pub const WGPUTextureFormat_WGPUTextureFormat_RG16Uint: WGPUTextureFormat = WGPUTextureFormat(15);
pub const WGPUTextureFormat_WGPUTextureFormat_RG16Sint: WGPUTextureFormat = WGPUTextureFormat(16);
pub const WGPUTextureFormat_WGPUTextureFormat_RG16Float: WGPUTextureFormat = WGPUTextureFormat(17);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA8Unorm: WGPUTextureFormat = WGPUTextureFormat(18);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA8UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(19);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA8Snorm: WGPUTextureFormat = WGPUTextureFormat(20);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA8Uint: WGPUTextureFormat = WGPUTextureFormat(21);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA8Sint: WGPUTextureFormat = WGPUTextureFormat(22);
pub const WGPUTextureFormat_WGPUTextureFormat_BGRA8Unorm: WGPUTextureFormat = WGPUTextureFormat(23);
pub const WGPUTextureFormat_WGPUTextureFormat_BGRA8UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(24);
pub const WGPUTextureFormat_WGPUTextureFormat_RGB10A2Uint: WGPUTextureFormat =
    WGPUTextureFormat(25);
pub const WGPUTextureFormat_WGPUTextureFormat_RGB10A2Unorm: WGPUTextureFormat =
    WGPUTextureFormat(26);
pub const WGPUTextureFormat_WGPUTextureFormat_RG11B10Ufloat: WGPUTextureFormat =
    WGPUTextureFormat(27);
pub const WGPUTextureFormat_WGPUTextureFormat_RGB9E5Ufloat: WGPUTextureFormat =
    WGPUTextureFormat(28);
pub const WGPUTextureFormat_WGPUTextureFormat_RG32Float: WGPUTextureFormat = WGPUTextureFormat(29);
pub const WGPUTextureFormat_WGPUTextureFormat_RG32Uint: WGPUTextureFormat = WGPUTextureFormat(30);
pub const WGPUTextureFormat_WGPUTextureFormat_RG32Sint: WGPUTextureFormat = WGPUTextureFormat(31);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA16Uint: WGPUTextureFormat = WGPUTextureFormat(32);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA16Sint: WGPUTextureFormat = WGPUTextureFormat(33);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA16Float: WGPUTextureFormat =
    WGPUTextureFormat(34);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA32Float: WGPUTextureFormat =
    WGPUTextureFormat(35);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA32Uint: WGPUTextureFormat = WGPUTextureFormat(36);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA32Sint: WGPUTextureFormat = WGPUTextureFormat(37);
pub const WGPUTextureFormat_WGPUTextureFormat_Stencil8: WGPUTextureFormat = WGPUTextureFormat(38);
pub const WGPUTextureFormat_WGPUTextureFormat_Depth16Unorm: WGPUTextureFormat =
    WGPUTextureFormat(39);
pub const WGPUTextureFormat_WGPUTextureFormat_Depth24Plus: WGPUTextureFormat =
    WGPUTextureFormat(40);
pub const WGPUTextureFormat_WGPUTextureFormat_Depth24PlusStencil8: WGPUTextureFormat =
    WGPUTextureFormat(41);
pub const WGPUTextureFormat_WGPUTextureFormat_Depth32Float: WGPUTextureFormat =
    WGPUTextureFormat(42);
pub const WGPUTextureFormat_WGPUTextureFormat_Depth32FloatStencil8: WGPUTextureFormat =
    WGPUTextureFormat(43);
pub const WGPUTextureFormat_WGPUTextureFormat_BC1RGBAUnorm: WGPUTextureFormat =
    WGPUTextureFormat(44);
pub const WGPUTextureFormat_WGPUTextureFormat_BC1RGBAUnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(45);
pub const WGPUTextureFormat_WGPUTextureFormat_BC2RGBAUnorm: WGPUTextureFormat =
    WGPUTextureFormat(46);
pub const WGPUTextureFormat_WGPUTextureFormat_BC2RGBAUnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(47);
pub const WGPUTextureFormat_WGPUTextureFormat_BC3RGBAUnorm: WGPUTextureFormat =
    WGPUTextureFormat(48);
pub const WGPUTextureFormat_WGPUTextureFormat_BC3RGBAUnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(49);
pub const WGPUTextureFormat_WGPUTextureFormat_BC4RUnorm: WGPUTextureFormat = WGPUTextureFormat(50);
pub const WGPUTextureFormat_WGPUTextureFormat_BC4RSnorm: WGPUTextureFormat = WGPUTextureFormat(51);
pub const WGPUTextureFormat_WGPUTextureFormat_BC5RGUnorm: WGPUTextureFormat = WGPUTextureFormat(52);
pub const WGPUTextureFormat_WGPUTextureFormat_BC5RGSnorm: WGPUTextureFormat = WGPUTextureFormat(53);
pub const WGPUTextureFormat_WGPUTextureFormat_BC6HRGBUfloat: WGPUTextureFormat =
    WGPUTextureFormat(54);
pub const WGPUTextureFormat_WGPUTextureFormat_BC6HRGBFloat: WGPUTextureFormat =
    WGPUTextureFormat(55);
pub const WGPUTextureFormat_WGPUTextureFormat_BC7RGBAUnorm: WGPUTextureFormat =
    WGPUTextureFormat(56);
pub const WGPUTextureFormat_WGPUTextureFormat_BC7RGBAUnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(57);
pub const WGPUTextureFormat_WGPUTextureFormat_ETC2RGB8Unorm: WGPUTextureFormat =
    WGPUTextureFormat(58);
pub const WGPUTextureFormat_WGPUTextureFormat_ETC2RGB8UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(59);
pub const WGPUTextureFormat_WGPUTextureFormat_ETC2RGB8A1Unorm: WGPUTextureFormat =
    WGPUTextureFormat(60);
pub const WGPUTextureFormat_WGPUTextureFormat_ETC2RGB8A1UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(61);
pub const WGPUTextureFormat_WGPUTextureFormat_ETC2RGBA8Unorm: WGPUTextureFormat =
    WGPUTextureFormat(62);
pub const WGPUTextureFormat_WGPUTextureFormat_ETC2RGBA8UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(63);
pub const WGPUTextureFormat_WGPUTextureFormat_EACR11Unorm: WGPUTextureFormat =
    WGPUTextureFormat(64);
pub const WGPUTextureFormat_WGPUTextureFormat_EACR11Snorm: WGPUTextureFormat =
    WGPUTextureFormat(65);
pub const WGPUTextureFormat_WGPUTextureFormat_EACRG11Unorm: WGPUTextureFormat =
    WGPUTextureFormat(66);
pub const WGPUTextureFormat_WGPUTextureFormat_EACRG11Snorm: WGPUTextureFormat =
    WGPUTextureFormat(67);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC4x4Unorm: WGPUTextureFormat =
    WGPUTextureFormat(68);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC4x4UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(69);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC5x4Unorm: WGPUTextureFormat =
    WGPUTextureFormat(70);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC5x4UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(71);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC5x5Unorm: WGPUTextureFormat =
    WGPUTextureFormat(72);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC5x5UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(73);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC6x5Unorm: WGPUTextureFormat =
    WGPUTextureFormat(74);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC6x5UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(75);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC6x6Unorm: WGPUTextureFormat =
    WGPUTextureFormat(76);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC6x6UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(77);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC8x5Unorm: WGPUTextureFormat =
    WGPUTextureFormat(78);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC8x5UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(79);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC8x6Unorm: WGPUTextureFormat =
    WGPUTextureFormat(80);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC8x6UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(81);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC8x8Unorm: WGPUTextureFormat =
    WGPUTextureFormat(82);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC8x8UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(83);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC10x5Unorm: WGPUTextureFormat =
    WGPUTextureFormat(84);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC10x5UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(85);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC10x6Unorm: WGPUTextureFormat =
    WGPUTextureFormat(86);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC10x6UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(87);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC10x8Unorm: WGPUTextureFormat =
    WGPUTextureFormat(88);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC10x8UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(89);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC10x10Unorm: WGPUTextureFormat =
    WGPUTextureFormat(90);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC10x10UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(91);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC12x10Unorm: WGPUTextureFormat =
    WGPUTextureFormat(92);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC12x10UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(93);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC12x12Unorm: WGPUTextureFormat =
    WGPUTextureFormat(94);
pub const WGPUTextureFormat_WGPUTextureFormat_ASTC12x12UnormSrgb: WGPUTextureFormat =
    WGPUTextureFormat(95);
pub const WGPUTextureFormat_WGPUTextureFormat_R16Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327680);
pub const WGPUTextureFormat_WGPUTextureFormat_RG16Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327681);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA16Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327682);
pub const WGPUTextureFormat_WGPUTextureFormat_R16Snorm: WGPUTextureFormat =
    WGPUTextureFormat(327683);
pub const WGPUTextureFormat_WGPUTextureFormat_RG16Snorm: WGPUTextureFormat =
    WGPUTextureFormat(327684);
pub const WGPUTextureFormat_WGPUTextureFormat_RGBA16Snorm: WGPUTextureFormat =
    WGPUTextureFormat(327685);
pub const WGPUTextureFormat_WGPUTextureFormat_R8BG8Biplanar420Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327686);
pub const WGPUTextureFormat_WGPUTextureFormat_R10X6BG10X6Biplanar420Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327687);
pub const WGPUTextureFormat_WGPUTextureFormat_R8BG8A8Triplanar420Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327688);
pub const WGPUTextureFormat_WGPUTextureFormat_R8BG8Biplanar422Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327689);
pub const WGPUTextureFormat_WGPUTextureFormat_R8BG8Biplanar444Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327690);
pub const WGPUTextureFormat_WGPUTextureFormat_R10X6BG10X6Biplanar422Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327691);
pub const WGPUTextureFormat_WGPUTextureFormat_R10X6BG10X6Biplanar444Unorm: WGPUTextureFormat =
    WGPUTextureFormat(327692);
pub const WGPUTextureFormat_WGPUTextureFormat_External: WGPUTextureFormat =
    WGPUTextureFormat(327693);
pub const WGPUTextureFormat_WGPUTextureFormat_Force32: WGPUTextureFormat =
    WGPUTextureFormat(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTextureFormat(pub ::core::ffi::c_int);
pub const WGPUTextureSampleType_WGPUTextureSampleType_BindingNotUsed: WGPUTextureSampleType =
    WGPUTextureSampleType(0);
pub const WGPUTextureSampleType_WGPUTextureSampleType_Undefined: WGPUTextureSampleType =
    WGPUTextureSampleType(1);
pub const WGPUTextureSampleType_WGPUTextureSampleType_Float: WGPUTextureSampleType =
    WGPUTextureSampleType(2);
pub const WGPUTextureSampleType_WGPUTextureSampleType_UnfilterableFloat: WGPUTextureSampleType =
    WGPUTextureSampleType(3);
pub const WGPUTextureSampleType_WGPUTextureSampleType_Depth: WGPUTextureSampleType =
    WGPUTextureSampleType(4);
pub const WGPUTextureSampleType_WGPUTextureSampleType_Sint: WGPUTextureSampleType =
    WGPUTextureSampleType(5);
pub const WGPUTextureSampleType_WGPUTextureSampleType_Uint: WGPUTextureSampleType =
    WGPUTextureSampleType(6);
pub const WGPUTextureSampleType_WGPUTextureSampleType_Force32: WGPUTextureSampleType =
    WGPUTextureSampleType(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTextureSampleType(pub ::core::ffi::c_int);
pub const WGPUTextureViewDimension_WGPUTextureViewDimension_Undefined: WGPUTextureViewDimension =
    WGPUTextureViewDimension(0);
pub const WGPUTextureViewDimension_WGPUTextureViewDimension_1D: WGPUTextureViewDimension =
    WGPUTextureViewDimension(1);
pub const WGPUTextureViewDimension_WGPUTextureViewDimension_2D: WGPUTextureViewDimension =
    WGPUTextureViewDimension(2);
pub const WGPUTextureViewDimension_WGPUTextureViewDimension_2DArray: WGPUTextureViewDimension =
    WGPUTextureViewDimension(3);
pub const WGPUTextureViewDimension_WGPUTextureViewDimension_Cube: WGPUTextureViewDimension =
    WGPUTextureViewDimension(4);
pub const WGPUTextureViewDimension_WGPUTextureViewDimension_CubeArray: WGPUTextureViewDimension =
    WGPUTextureViewDimension(5);
pub const WGPUTextureViewDimension_WGPUTextureViewDimension_3D: WGPUTextureViewDimension =
    WGPUTextureViewDimension(6);
pub const WGPUTextureViewDimension_WGPUTextureViewDimension_Force32: WGPUTextureViewDimension =
    WGPUTextureViewDimension(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTextureViewDimension(pub ::core::ffi::c_int);
pub const WGPUToneMappingMode_WGPUToneMappingMode_Standard: WGPUToneMappingMode =
    WGPUToneMappingMode(1);
pub const WGPUToneMappingMode_WGPUToneMappingMode_Extended: WGPUToneMappingMode =
    WGPUToneMappingMode(2);
pub const WGPUToneMappingMode_WGPUToneMappingMode_Force32: WGPUToneMappingMode =
    WGPUToneMappingMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUToneMappingMode(pub ::core::ffi::c_int);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint8: WGPUVertexFormat = WGPUVertexFormat(1);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint8x2: WGPUVertexFormat = WGPUVertexFormat(2);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint8x4: WGPUVertexFormat = WGPUVertexFormat(3);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint8: WGPUVertexFormat = WGPUVertexFormat(4);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint8x2: WGPUVertexFormat = WGPUVertexFormat(5);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint8x4: WGPUVertexFormat = WGPUVertexFormat(6);
pub const WGPUVertexFormat_WGPUVertexFormat_Unorm8: WGPUVertexFormat = WGPUVertexFormat(7);
pub const WGPUVertexFormat_WGPUVertexFormat_Unorm8x2: WGPUVertexFormat = WGPUVertexFormat(8);
pub const WGPUVertexFormat_WGPUVertexFormat_Unorm8x4: WGPUVertexFormat = WGPUVertexFormat(9);
pub const WGPUVertexFormat_WGPUVertexFormat_Snorm8: WGPUVertexFormat = WGPUVertexFormat(10);
pub const WGPUVertexFormat_WGPUVertexFormat_Snorm8x2: WGPUVertexFormat = WGPUVertexFormat(11);
pub const WGPUVertexFormat_WGPUVertexFormat_Snorm8x4: WGPUVertexFormat = WGPUVertexFormat(12);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint16: WGPUVertexFormat = WGPUVertexFormat(13);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint16x2: WGPUVertexFormat = WGPUVertexFormat(14);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint16x4: WGPUVertexFormat = WGPUVertexFormat(15);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint16: WGPUVertexFormat = WGPUVertexFormat(16);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint16x2: WGPUVertexFormat = WGPUVertexFormat(17);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint16x4: WGPUVertexFormat = WGPUVertexFormat(18);
pub const WGPUVertexFormat_WGPUVertexFormat_Unorm16: WGPUVertexFormat = WGPUVertexFormat(19);
pub const WGPUVertexFormat_WGPUVertexFormat_Unorm16x2: WGPUVertexFormat = WGPUVertexFormat(20);
pub const WGPUVertexFormat_WGPUVertexFormat_Unorm16x4: WGPUVertexFormat = WGPUVertexFormat(21);
pub const WGPUVertexFormat_WGPUVertexFormat_Snorm16: WGPUVertexFormat = WGPUVertexFormat(22);
pub const WGPUVertexFormat_WGPUVertexFormat_Snorm16x2: WGPUVertexFormat = WGPUVertexFormat(23);
pub const WGPUVertexFormat_WGPUVertexFormat_Snorm16x4: WGPUVertexFormat = WGPUVertexFormat(24);
pub const WGPUVertexFormat_WGPUVertexFormat_Float16: WGPUVertexFormat = WGPUVertexFormat(25);
pub const WGPUVertexFormat_WGPUVertexFormat_Float16x2: WGPUVertexFormat = WGPUVertexFormat(26);
pub const WGPUVertexFormat_WGPUVertexFormat_Float16x4: WGPUVertexFormat = WGPUVertexFormat(27);
pub const WGPUVertexFormat_WGPUVertexFormat_Float32: WGPUVertexFormat = WGPUVertexFormat(28);
pub const WGPUVertexFormat_WGPUVertexFormat_Float32x2: WGPUVertexFormat = WGPUVertexFormat(29);
pub const WGPUVertexFormat_WGPUVertexFormat_Float32x3: WGPUVertexFormat = WGPUVertexFormat(30);
pub const WGPUVertexFormat_WGPUVertexFormat_Float32x4: WGPUVertexFormat = WGPUVertexFormat(31);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint32: WGPUVertexFormat = WGPUVertexFormat(32);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint32x2: WGPUVertexFormat = WGPUVertexFormat(33);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint32x3: WGPUVertexFormat = WGPUVertexFormat(34);
pub const WGPUVertexFormat_WGPUVertexFormat_Uint32x4: WGPUVertexFormat = WGPUVertexFormat(35);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint32: WGPUVertexFormat = WGPUVertexFormat(36);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint32x2: WGPUVertexFormat = WGPUVertexFormat(37);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint32x3: WGPUVertexFormat = WGPUVertexFormat(38);
pub const WGPUVertexFormat_WGPUVertexFormat_Sint32x4: WGPUVertexFormat = WGPUVertexFormat(39);
pub const WGPUVertexFormat_WGPUVertexFormat_Unorm10_10_10_2: WGPUVertexFormat =
    WGPUVertexFormat(40);
pub const WGPUVertexFormat_WGPUVertexFormat_Unorm8x4BGRA: WGPUVertexFormat = WGPUVertexFormat(41);
pub const WGPUVertexFormat_WGPUVertexFormat_Force32: WGPUVertexFormat =
    WGPUVertexFormat(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUVertexFormat(pub ::core::ffi::c_int);
pub const WGPUVertexStepMode_WGPUVertexStepMode_Undefined: WGPUVertexStepMode =
    WGPUVertexStepMode(0);
pub const WGPUVertexStepMode_WGPUVertexStepMode_Vertex: WGPUVertexStepMode = WGPUVertexStepMode(1);
pub const WGPUVertexStepMode_WGPUVertexStepMode_Instance: WGPUVertexStepMode =
    WGPUVertexStepMode(2);
pub const WGPUVertexStepMode_WGPUVertexStepMode_Force32: WGPUVertexStepMode =
    WGPUVertexStepMode(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUVertexStepMode(pub ::core::ffi::c_int);
pub const WGPUWaitStatus_WGPUWaitStatus_Success: WGPUWaitStatus = WGPUWaitStatus(1);
pub const WGPUWaitStatus_WGPUWaitStatus_TimedOut: WGPUWaitStatus = WGPUWaitStatus(2);
pub const WGPUWaitStatus_WGPUWaitStatus_Error: WGPUWaitStatus = WGPUWaitStatus(3);
pub const WGPUWaitStatus_WGPUWaitStatus_Force32: WGPUWaitStatus = WGPUWaitStatus(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUWaitStatus(pub ::core::ffi::c_int);
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_ReadonlyAndReadwriteStorageTextures : WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName (1) ;
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_Packed4x8IntegerDotProduct:
    WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName(2);
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_UnrestrictedPointerParameters:
    WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName(3);
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_PointerCompositeAccess:
    WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName(4);
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_SizedBindingArray:
    WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName(5);
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_ChromiumTestingUnimplemented:
    WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName(327680);
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_ChromiumTestingUnsafeExperimental : WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName (327681) ;
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_ChromiumTestingExperimental:
    WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName(327682);
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_ChromiumTestingShippedWithKillswitch : WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName (327683) ;
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_ChromiumTestingShipped:
    WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName(327684);
pub const WGPUWGSLLanguageFeatureName_WGPUWGSLLanguageFeatureName_Force32:
    WGPUWGSLLanguageFeatureName = WGPUWGSLLanguageFeatureName(2147483647);
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUWGSLLanguageFeatureName(pub ::core::ffi::c_int);
pub type WGPUCallback =
    ::core::option::Option<unsafe extern "C" fn(userdata: *mut ::core::ffi::c_void)>;
pub type WGPUDawnLoadCacheDataFunction = ::core::option::Option<
    unsafe extern "C" fn(
        key: *const ::core::ffi::c_void,
        keySize: usize,
        value: *mut ::core::ffi::c_void,
        valueSize: usize,
        userdata: *mut ::core::ffi::c_void,
    ) -> usize,
>;
pub type WGPUDawnStoreCacheDataFunction = ::core::option::Option<
    unsafe extern "C" fn(
        key: *const ::core::ffi::c_void,
        keySize: usize,
        value: *const ::core::ffi::c_void,
        valueSize: usize,
        userdata: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPUProc = ::core::option::Option<unsafe extern "C" fn()>;
pub type WGPUBufferMapCallback = ::core::option::Option<
    unsafe extern "C" fn(
        status: WGPUMapAsyncStatus,
        message: WGPUStringView,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPUCompilationInfoCallback = ::core::option::Option<
    unsafe extern "C" fn(
        status: WGPUCompilationInfoRequestStatus,
        compilationInfo: *const WGPUCompilationInfo,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPUCreateComputePipelineAsyncCallback = ::core::option::Option<
    unsafe extern "C" fn(
        status: WGPUCreatePipelineAsyncStatus,
        pipeline: WGPUComputePipeline,
        message: WGPUStringView,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPUCreateRenderPipelineAsyncCallback = ::core::option::Option<
    unsafe extern "C" fn(
        status: WGPUCreatePipelineAsyncStatus,
        pipeline: WGPURenderPipeline,
        message: WGPUStringView,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPUDeviceLostCallback = ::core::option::Option<
    unsafe extern "C" fn(
        device: *const WGPUDevice,
        reason: WGPUDeviceLostReason,
        message: WGPUStringView,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPULoggingCallback = ::core::option::Option<
    unsafe extern "C" fn(
        type_: WGPULoggingType,
        message: WGPUStringView,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPUPopErrorScopeCallback = ::core::option::Option<
    unsafe extern "C" fn(
        status: WGPUPopErrorScopeStatus,
        type_: WGPUErrorType,
        message: WGPUStringView,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPUQueueWorkDoneCallback = ::core::option::Option<
    unsafe extern "C" fn(
        status: WGPUQueueWorkDoneStatus,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPURequestAdapterCallback = ::core::option::Option<
    unsafe extern "C" fn(
        status: WGPURequestAdapterStatus,
        adapter: WGPUAdapter,
        message: WGPUStringView,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPURequestDeviceCallback = ::core::option::Option<
    unsafe extern "C" fn(
        status: WGPURequestDeviceStatus,
        device: WGPUDevice,
        message: WGPUStringView,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
pub type WGPUUncapturedErrorCallback = ::core::option::Option<
    unsafe extern "C" fn(
        device: *const WGPUDevice,
        type_: WGPUErrorType,
        message: WGPUStringView,
        userdata1: *mut ::core::ffi::c_void,
        userdata2: *mut ::core::ffi::c_void,
    ),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUChainedStruct {
    pub next: *mut WGPUChainedStruct,
    pub sType: WGPUSType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUChainedStruct"][::core::mem::size_of::<WGPUChainedStruct>() - 16usize];
    ["Alignment of WGPUChainedStruct"][::core::mem::align_of::<WGPUChainedStruct>() - 8usize];
    ["Offset of field: WGPUChainedStruct::next"]
        [::core::mem::offset_of!(WGPUChainedStruct, next) - 0usize];
    ["Offset of field: WGPUChainedStruct::sType"]
        [::core::mem::offset_of!(WGPUChainedStruct, sType) - 8usize];
};
impl Default for WGPUChainedStruct {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBufferMapCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub mode: WGPUCallbackMode,
    pub callback: WGPUBufferMapCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBufferMapCallbackInfo"]
        [::core::mem::size_of::<WGPUBufferMapCallbackInfo>() - 40usize];
    ["Alignment of WGPUBufferMapCallbackInfo"]
        [::core::mem::align_of::<WGPUBufferMapCallbackInfo>() - 8usize];
    ["Offset of field: WGPUBufferMapCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUBufferMapCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUBufferMapCallbackInfo::mode"]
        [::core::mem::offset_of!(WGPUBufferMapCallbackInfo, mode) - 8usize];
    ["Offset of field: WGPUBufferMapCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPUBufferMapCallbackInfo, callback) - 16usize];
    ["Offset of field: WGPUBufferMapCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPUBufferMapCallbackInfo, userdata1) - 24usize];
    ["Offset of field: WGPUBufferMapCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPUBufferMapCallbackInfo, userdata2) - 32usize];
};
impl Default for WGPUBufferMapCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCompilationInfoCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub mode: WGPUCallbackMode,
    pub callback: WGPUCompilationInfoCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUCompilationInfoCallbackInfo"]
        [::core::mem::size_of::<WGPUCompilationInfoCallbackInfo>() - 40usize];
    ["Alignment of WGPUCompilationInfoCallbackInfo"]
        [::core::mem::align_of::<WGPUCompilationInfoCallbackInfo>() - 8usize];
    ["Offset of field: WGPUCompilationInfoCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUCompilationInfoCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUCompilationInfoCallbackInfo::mode"]
        [::core::mem::offset_of!(WGPUCompilationInfoCallbackInfo, mode) - 8usize];
    ["Offset of field: WGPUCompilationInfoCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPUCompilationInfoCallbackInfo, callback) - 16usize];
    ["Offset of field: WGPUCompilationInfoCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPUCompilationInfoCallbackInfo, userdata1) - 24usize];
    ["Offset of field: WGPUCompilationInfoCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPUCompilationInfoCallbackInfo, userdata2) - 32usize];
};
impl Default for WGPUCompilationInfoCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCreateComputePipelineAsyncCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub mode: WGPUCallbackMode,
    pub callback: WGPUCreateComputePipelineAsyncCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUCreateComputePipelineAsyncCallbackInfo"]
        [::core::mem::size_of::<WGPUCreateComputePipelineAsyncCallbackInfo>() - 40usize];
    ["Alignment of WGPUCreateComputePipelineAsyncCallbackInfo"]
        [::core::mem::align_of::<WGPUCreateComputePipelineAsyncCallbackInfo>() - 8usize];
    ["Offset of field: WGPUCreateComputePipelineAsyncCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUCreateComputePipelineAsyncCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUCreateComputePipelineAsyncCallbackInfo::mode"]
        [::core::mem::offset_of!(WGPUCreateComputePipelineAsyncCallbackInfo, mode) - 8usize];
    ["Offset of field: WGPUCreateComputePipelineAsyncCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPUCreateComputePipelineAsyncCallbackInfo, callback) - 16usize];
    ["Offset of field: WGPUCreateComputePipelineAsyncCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPUCreateComputePipelineAsyncCallbackInfo, userdata1) - 24usize];
    ["Offset of field: WGPUCreateComputePipelineAsyncCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPUCreateComputePipelineAsyncCallbackInfo, userdata2) - 32usize];
};
impl Default for WGPUCreateComputePipelineAsyncCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCreateRenderPipelineAsyncCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub mode: WGPUCallbackMode,
    pub callback: WGPUCreateRenderPipelineAsyncCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUCreateRenderPipelineAsyncCallbackInfo"]
        [::core::mem::size_of::<WGPUCreateRenderPipelineAsyncCallbackInfo>() - 40usize];
    ["Alignment of WGPUCreateRenderPipelineAsyncCallbackInfo"]
        [::core::mem::align_of::<WGPUCreateRenderPipelineAsyncCallbackInfo>() - 8usize];
    ["Offset of field: WGPUCreateRenderPipelineAsyncCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUCreateRenderPipelineAsyncCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUCreateRenderPipelineAsyncCallbackInfo::mode"]
        [::core::mem::offset_of!(WGPUCreateRenderPipelineAsyncCallbackInfo, mode) - 8usize];
    ["Offset of field: WGPUCreateRenderPipelineAsyncCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPUCreateRenderPipelineAsyncCallbackInfo, callback) - 16usize];
    ["Offset of field: WGPUCreateRenderPipelineAsyncCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPUCreateRenderPipelineAsyncCallbackInfo, userdata1) - 24usize];
    ["Offset of field: WGPUCreateRenderPipelineAsyncCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPUCreateRenderPipelineAsyncCallbackInfo, userdata2) - 32usize];
};
impl Default for WGPUCreateRenderPipelineAsyncCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDeviceLostCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub mode: WGPUCallbackMode,
    pub callback: WGPUDeviceLostCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDeviceLostCallbackInfo"]
        [::core::mem::size_of::<WGPUDeviceLostCallbackInfo>() - 40usize];
    ["Alignment of WGPUDeviceLostCallbackInfo"]
        [::core::mem::align_of::<WGPUDeviceLostCallbackInfo>() - 8usize];
    ["Offset of field: WGPUDeviceLostCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUDeviceLostCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUDeviceLostCallbackInfo::mode"]
        [::core::mem::offset_of!(WGPUDeviceLostCallbackInfo, mode) - 8usize];
    ["Offset of field: WGPUDeviceLostCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPUDeviceLostCallbackInfo, callback) - 16usize];
    ["Offset of field: WGPUDeviceLostCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPUDeviceLostCallbackInfo, userdata1) - 24usize];
    ["Offset of field: WGPUDeviceLostCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPUDeviceLostCallbackInfo, userdata2) - 32usize];
};
impl Default for WGPUDeviceLostCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPULoggingCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub callback: WGPULoggingCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPULoggingCallbackInfo"]
        [::core::mem::size_of::<WGPULoggingCallbackInfo>() - 32usize];
    ["Alignment of WGPULoggingCallbackInfo"]
        [::core::mem::align_of::<WGPULoggingCallbackInfo>() - 8usize];
    ["Offset of field: WGPULoggingCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPULoggingCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPULoggingCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPULoggingCallbackInfo, callback) - 8usize];
    ["Offset of field: WGPULoggingCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPULoggingCallbackInfo, userdata1) - 16usize];
    ["Offset of field: WGPULoggingCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPULoggingCallbackInfo, userdata2) - 24usize];
};
impl Default for WGPULoggingCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPopErrorScopeCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub mode: WGPUCallbackMode,
    pub callback: WGPUPopErrorScopeCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUPopErrorScopeCallbackInfo"]
        [::core::mem::size_of::<WGPUPopErrorScopeCallbackInfo>() - 40usize];
    ["Alignment of WGPUPopErrorScopeCallbackInfo"]
        [::core::mem::align_of::<WGPUPopErrorScopeCallbackInfo>() - 8usize];
    ["Offset of field: WGPUPopErrorScopeCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUPopErrorScopeCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUPopErrorScopeCallbackInfo::mode"]
        [::core::mem::offset_of!(WGPUPopErrorScopeCallbackInfo, mode) - 8usize];
    ["Offset of field: WGPUPopErrorScopeCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPUPopErrorScopeCallbackInfo, callback) - 16usize];
    ["Offset of field: WGPUPopErrorScopeCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPUPopErrorScopeCallbackInfo, userdata1) - 24usize];
    ["Offset of field: WGPUPopErrorScopeCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPUPopErrorScopeCallbackInfo, userdata2) - 32usize];
};
impl Default for WGPUPopErrorScopeCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUQueueWorkDoneCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub mode: WGPUCallbackMode,
    pub callback: WGPUQueueWorkDoneCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUQueueWorkDoneCallbackInfo"]
        [::core::mem::size_of::<WGPUQueueWorkDoneCallbackInfo>() - 40usize];
    ["Alignment of WGPUQueueWorkDoneCallbackInfo"]
        [::core::mem::align_of::<WGPUQueueWorkDoneCallbackInfo>() - 8usize];
    ["Offset of field: WGPUQueueWorkDoneCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUQueueWorkDoneCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUQueueWorkDoneCallbackInfo::mode"]
        [::core::mem::offset_of!(WGPUQueueWorkDoneCallbackInfo, mode) - 8usize];
    ["Offset of field: WGPUQueueWorkDoneCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPUQueueWorkDoneCallbackInfo, callback) - 16usize];
    ["Offset of field: WGPUQueueWorkDoneCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPUQueueWorkDoneCallbackInfo, userdata1) - 24usize];
    ["Offset of field: WGPUQueueWorkDoneCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPUQueueWorkDoneCallbackInfo, userdata2) - 32usize];
};
impl Default for WGPUQueueWorkDoneCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURequestAdapterCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub mode: WGPUCallbackMode,
    pub callback: WGPURequestAdapterCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURequestAdapterCallbackInfo"]
        [::core::mem::size_of::<WGPURequestAdapterCallbackInfo>() - 40usize];
    ["Alignment of WGPURequestAdapterCallbackInfo"]
        [::core::mem::align_of::<WGPURequestAdapterCallbackInfo>() - 8usize];
    ["Offset of field: WGPURequestAdapterCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPURequestAdapterCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPURequestAdapterCallbackInfo::mode"]
        [::core::mem::offset_of!(WGPURequestAdapterCallbackInfo, mode) - 8usize];
    ["Offset of field: WGPURequestAdapterCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPURequestAdapterCallbackInfo, callback) - 16usize];
    ["Offset of field: WGPURequestAdapterCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPURequestAdapterCallbackInfo, userdata1) - 24usize];
    ["Offset of field: WGPURequestAdapterCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPURequestAdapterCallbackInfo, userdata2) - 32usize];
};
impl Default for WGPURequestAdapterCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURequestDeviceCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub mode: WGPUCallbackMode,
    pub callback: WGPURequestDeviceCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURequestDeviceCallbackInfo"]
        [::core::mem::size_of::<WGPURequestDeviceCallbackInfo>() - 40usize];
    ["Alignment of WGPURequestDeviceCallbackInfo"]
        [::core::mem::align_of::<WGPURequestDeviceCallbackInfo>() - 8usize];
    ["Offset of field: WGPURequestDeviceCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPURequestDeviceCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPURequestDeviceCallbackInfo::mode"]
        [::core::mem::offset_of!(WGPURequestDeviceCallbackInfo, mode) - 8usize];
    ["Offset of field: WGPURequestDeviceCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPURequestDeviceCallbackInfo, callback) - 16usize];
    ["Offset of field: WGPURequestDeviceCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPURequestDeviceCallbackInfo, userdata1) - 24usize];
    ["Offset of field: WGPURequestDeviceCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPURequestDeviceCallbackInfo, userdata2) - 32usize];
};
impl Default for WGPURequestDeviceCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUUncapturedErrorCallbackInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub callback: WGPUUncapturedErrorCallback,
    pub userdata1: *mut ::core::ffi::c_void,
    pub userdata2: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUUncapturedErrorCallbackInfo"]
        [::core::mem::size_of::<WGPUUncapturedErrorCallbackInfo>() - 32usize];
    ["Alignment of WGPUUncapturedErrorCallbackInfo"]
        [::core::mem::align_of::<WGPUUncapturedErrorCallbackInfo>() - 8usize];
    ["Offset of field: WGPUUncapturedErrorCallbackInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUUncapturedErrorCallbackInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUUncapturedErrorCallbackInfo::callback"]
        [::core::mem::offset_of!(WGPUUncapturedErrorCallbackInfo, callback) - 8usize];
    ["Offset of field: WGPUUncapturedErrorCallbackInfo::userdata1"]
        [::core::mem::offset_of!(WGPUUncapturedErrorCallbackInfo, userdata1) - 16usize];
    ["Offset of field: WGPUUncapturedErrorCallbackInfo::userdata2"]
        [::core::mem::offset_of!(WGPUUncapturedErrorCallbackInfo, userdata2) - 24usize];
};
impl Default for WGPUUncapturedErrorCallbackInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAdapterPropertiesD3D {
    pub chain: WGPUChainedStruct,
    pub shaderModel: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUAdapterPropertiesD3D"]
        [::core::mem::size_of::<WGPUAdapterPropertiesD3D>() - 24usize];
    ["Alignment of WGPUAdapterPropertiesD3D"]
        [::core::mem::align_of::<WGPUAdapterPropertiesD3D>() - 8usize];
    ["Offset of field: WGPUAdapterPropertiesD3D::chain"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesD3D, chain) - 0usize];
    ["Offset of field: WGPUAdapterPropertiesD3D::shaderModel"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesD3D, shaderModel) - 16usize];
};
impl Default for WGPUAdapterPropertiesD3D {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAdapterPropertiesSubgroups {
    pub chain: WGPUChainedStruct,
    pub subgroupMinSize: u32,
    pub subgroupMaxSize: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUAdapterPropertiesSubgroups"]
        [::core::mem::size_of::<WGPUAdapterPropertiesSubgroups>() - 24usize];
    ["Alignment of WGPUAdapterPropertiesSubgroups"]
        [::core::mem::align_of::<WGPUAdapterPropertiesSubgroups>() - 8usize];
    ["Offset of field: WGPUAdapterPropertiesSubgroups::chain"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesSubgroups, chain) - 0usize];
    ["Offset of field: WGPUAdapterPropertiesSubgroups::subgroupMinSize"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesSubgroups, subgroupMinSize) - 16usize];
    ["Offset of field: WGPUAdapterPropertiesSubgroups::subgroupMaxSize"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesSubgroups, subgroupMaxSize) - 20usize];
};
impl Default for WGPUAdapterPropertiesSubgroups {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAdapterPropertiesVk {
    pub chain: WGPUChainedStruct,
    pub driverVersion: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUAdapterPropertiesVk"]
        [::core::mem::size_of::<WGPUAdapterPropertiesVk>() - 24usize];
    ["Alignment of WGPUAdapterPropertiesVk"]
        [::core::mem::align_of::<WGPUAdapterPropertiesVk>() - 8usize];
    ["Offset of field: WGPUAdapterPropertiesVk::chain"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesVk, chain) - 0usize];
    ["Offset of field: WGPUAdapterPropertiesVk::driverVersion"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesVk, driverVersion) - 16usize];
};
impl Default for WGPUAdapterPropertiesVk {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBindGroupLayoutEntryArraySize {
    pub chain: WGPUChainedStruct,
    pub arraySize: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBindGroupLayoutEntryArraySize"]
        [::core::mem::size_of::<WGPUBindGroupLayoutEntryArraySize>() - 24usize];
    ["Alignment of WGPUBindGroupLayoutEntryArraySize"]
        [::core::mem::align_of::<WGPUBindGroupLayoutEntryArraySize>() - 8usize];
    ["Offset of field: WGPUBindGroupLayoutEntryArraySize::chain"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutEntryArraySize, chain) - 0usize];
    ["Offset of field: WGPUBindGroupLayoutEntryArraySize::arraySize"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutEntryArraySize, arraySize) - 16usize];
};
impl Default for WGPUBindGroupLayoutEntryArraySize {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBlendComponent {
    pub operation: WGPUBlendOperation,
    pub srcFactor: WGPUBlendFactor,
    pub dstFactor: WGPUBlendFactor,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBlendComponent"][::core::mem::size_of::<WGPUBlendComponent>() - 12usize];
    ["Alignment of WGPUBlendComponent"][::core::mem::align_of::<WGPUBlendComponent>() - 4usize];
    ["Offset of field: WGPUBlendComponent::operation"]
        [::core::mem::offset_of!(WGPUBlendComponent, operation) - 0usize];
    ["Offset of field: WGPUBlendComponent::srcFactor"]
        [::core::mem::offset_of!(WGPUBlendComponent, srcFactor) - 4usize];
    ["Offset of field: WGPUBlendComponent::dstFactor"]
        [::core::mem::offset_of!(WGPUBlendComponent, dstFactor) - 8usize];
};
impl Default for WGPUBlendComponent {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBufferBindingLayout {
    pub nextInChain: *mut WGPUChainedStruct,
    pub type_: WGPUBufferBindingType,
    pub hasDynamicOffset: WGPUBool,
    pub minBindingSize: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBufferBindingLayout"]
        [::core::mem::size_of::<WGPUBufferBindingLayout>() - 24usize];
    ["Alignment of WGPUBufferBindingLayout"]
        [::core::mem::align_of::<WGPUBufferBindingLayout>() - 8usize];
    ["Offset of field: WGPUBufferBindingLayout::nextInChain"]
        [::core::mem::offset_of!(WGPUBufferBindingLayout, nextInChain) - 0usize];
    ["Offset of field: WGPUBufferBindingLayout::type_"]
        [::core::mem::offset_of!(WGPUBufferBindingLayout, type_) - 8usize];
    ["Offset of field: WGPUBufferBindingLayout::hasDynamicOffset"]
        [::core::mem::offset_of!(WGPUBufferBindingLayout, hasDynamicOffset) - 12usize];
    ["Offset of field: WGPUBufferBindingLayout::minBindingSize"]
        [::core::mem::offset_of!(WGPUBufferBindingLayout, minBindingSize) - 16usize];
};
impl Default for WGPUBufferBindingLayout {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBufferHostMappedPointer {
    pub chain: WGPUChainedStruct,
    pub pointer: *mut ::core::ffi::c_void,
    pub disposeCallback: WGPUCallback,
    pub userdata: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBufferHostMappedPointer"]
        [::core::mem::size_of::<WGPUBufferHostMappedPointer>() - 40usize];
    ["Alignment of WGPUBufferHostMappedPointer"]
        [::core::mem::align_of::<WGPUBufferHostMappedPointer>() - 8usize];
    ["Offset of field: WGPUBufferHostMappedPointer::chain"]
        [::core::mem::offset_of!(WGPUBufferHostMappedPointer, chain) - 0usize];
    ["Offset of field: WGPUBufferHostMappedPointer::pointer"]
        [::core::mem::offset_of!(WGPUBufferHostMappedPointer, pointer) - 16usize];
    ["Offset of field: WGPUBufferHostMappedPointer::disposeCallback"]
        [::core::mem::offset_of!(WGPUBufferHostMappedPointer, disposeCallback) - 24usize];
    ["Offset of field: WGPUBufferHostMappedPointer::userdata"]
        [::core::mem::offset_of!(WGPUBufferHostMappedPointer, userdata) - 32usize];
};
impl Default for WGPUBufferHostMappedPointer {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialOrd, PartialEq)]
pub struct WGPUColor {
    pub r: f64,
    pub g: f64,
    pub b: f64,
    pub a: f64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUColor"][::core::mem::size_of::<WGPUColor>() - 32usize];
    ["Alignment of WGPUColor"][::core::mem::align_of::<WGPUColor>() - 8usize];
    ["Offset of field: WGPUColor::r"][::core::mem::offset_of!(WGPUColor, r) - 0usize];
    ["Offset of field: WGPUColor::g"][::core::mem::offset_of!(WGPUColor, g) - 8usize];
    ["Offset of field: WGPUColor::b"][::core::mem::offset_of!(WGPUColor, b) - 16usize];
    ["Offset of field: WGPUColor::a"][::core::mem::offset_of!(WGPUColor, a) - 24usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUColorTargetStateExpandResolveTextureDawn {
    pub chain: WGPUChainedStruct,
    pub enabled: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUColorTargetStateExpandResolveTextureDawn"]
        [::core::mem::size_of::<WGPUColorTargetStateExpandResolveTextureDawn>() - 24usize];
    ["Alignment of WGPUColorTargetStateExpandResolveTextureDawn"]
        [::core::mem::align_of::<WGPUColorTargetStateExpandResolveTextureDawn>() - 8usize];
    ["Offset of field: WGPUColorTargetStateExpandResolveTextureDawn::chain"]
        [::core::mem::offset_of!(WGPUColorTargetStateExpandResolveTextureDawn, chain) - 0usize];
    ["Offset of field: WGPUColorTargetStateExpandResolveTextureDawn::enabled"]
        [::core::mem::offset_of!(WGPUColorTargetStateExpandResolveTextureDawn, enabled) - 16usize];
};
impl Default for WGPUColorTargetStateExpandResolveTextureDawn {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCommandBufferDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUCommandBufferDescriptor"]
        [::core::mem::size_of::<WGPUCommandBufferDescriptor>() - 24usize];
    ["Alignment of WGPUCommandBufferDescriptor"]
        [::core::mem::align_of::<WGPUCommandBufferDescriptor>() - 8usize];
    ["Offset of field: WGPUCommandBufferDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUCommandBufferDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUCommandBufferDescriptor::label"]
        [::core::mem::offset_of!(WGPUCommandBufferDescriptor, label) - 8usize];
};
impl Default for WGPUCommandBufferDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct WGPUConstantEntry {
    pub nextInChain: *mut WGPUChainedStruct,
    pub key: WGPUStringView,
    pub value: f64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUConstantEntry"][::core::mem::size_of::<WGPUConstantEntry>() - 32usize];
    ["Alignment of WGPUConstantEntry"][::core::mem::align_of::<WGPUConstantEntry>() - 8usize];
    ["Offset of field: WGPUConstantEntry::nextInChain"]
        [::core::mem::offset_of!(WGPUConstantEntry, nextInChain) - 0usize];
    ["Offset of field: WGPUConstantEntry::key"]
        [::core::mem::offset_of!(WGPUConstantEntry, key) - 8usize];
    ["Offset of field: WGPUConstantEntry::value"]
        [::core::mem::offset_of!(WGPUConstantEntry, value) - 24usize];
};
impl Default for WGPUConstantEntry {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCopyTextureForBrowserOptions {
    pub nextInChain: *mut WGPUChainedStruct,
    pub flipY: WGPUBool,
    pub needsColorSpaceConversion: WGPUBool,
    pub srcAlphaMode: WGPUAlphaMode,
    pub srcTransferFunctionParameters: *const f32,
    pub conversionMatrix: *const f32,
    pub dstTransferFunctionParameters: *const f32,
    pub dstAlphaMode: WGPUAlphaMode,
    pub internalUsage: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUCopyTextureForBrowserOptions"]
        [::core::mem::size_of::<WGPUCopyTextureForBrowserOptions>() - 56usize];
    ["Alignment of WGPUCopyTextureForBrowserOptions"]
        [::core::mem::align_of::<WGPUCopyTextureForBrowserOptions>() - 8usize];
    ["Offset of field: WGPUCopyTextureForBrowserOptions::nextInChain"]
        [::core::mem::offset_of!(WGPUCopyTextureForBrowserOptions, nextInChain) - 0usize];
    ["Offset of field: WGPUCopyTextureForBrowserOptions::flipY"]
        [::core::mem::offset_of!(WGPUCopyTextureForBrowserOptions, flipY) - 8usize];
    ["Offset of field: WGPUCopyTextureForBrowserOptions::needsColorSpaceConversion"][::core::mem::offset_of!(
        WGPUCopyTextureForBrowserOptions,
        needsColorSpaceConversion
    ) - 12usize];
    ["Offset of field: WGPUCopyTextureForBrowserOptions::srcAlphaMode"]
        [::core::mem::offset_of!(WGPUCopyTextureForBrowserOptions, srcAlphaMode) - 16usize];
    ["Offset of field: WGPUCopyTextureForBrowserOptions::srcTransferFunctionParameters"][::core::mem::offset_of!(
        WGPUCopyTextureForBrowserOptions,
        srcTransferFunctionParameters
    )
        - 24usize];
    ["Offset of field: WGPUCopyTextureForBrowserOptions::conversionMatrix"]
        [::core::mem::offset_of!(WGPUCopyTextureForBrowserOptions, conversionMatrix) - 32usize];
    ["Offset of field: WGPUCopyTextureForBrowserOptions::dstTransferFunctionParameters"][::core::mem::offset_of!(
        WGPUCopyTextureForBrowserOptions,
        dstTransferFunctionParameters
    )
        - 40usize];
    ["Offset of field: WGPUCopyTextureForBrowserOptions::dstAlphaMode"]
        [::core::mem::offset_of!(WGPUCopyTextureForBrowserOptions, dstAlphaMode) - 48usize];
    ["Offset of field: WGPUCopyTextureForBrowserOptions::internalUsage"]
        [::core::mem::offset_of!(WGPUCopyTextureForBrowserOptions, internalUsage) - 52usize];
};
impl Default for WGPUCopyTextureForBrowserOptions {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnAdapterPropertiesPowerPreference {
    pub chain: WGPUChainedStruct,
    pub powerPreference: WGPUPowerPreference,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnAdapterPropertiesPowerPreference"]
        [::core::mem::size_of::<WGPUDawnAdapterPropertiesPowerPreference>() - 24usize];
    ["Alignment of WGPUDawnAdapterPropertiesPowerPreference"]
        [::core::mem::align_of::<WGPUDawnAdapterPropertiesPowerPreference>() - 8usize];
    ["Offset of field: WGPUDawnAdapterPropertiesPowerPreference::chain"]
        [::core::mem::offset_of!(WGPUDawnAdapterPropertiesPowerPreference, chain) - 0usize];
    ["Offset of field: WGPUDawnAdapterPropertiesPowerPreference::powerPreference"][::core::mem::offset_of!(
        WGPUDawnAdapterPropertiesPowerPreference,
        powerPreference
    ) - 16usize];
};
impl Default for WGPUDawnAdapterPropertiesPowerPreference {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnBufferDescriptorErrorInfoFromWireClient {
    pub chain: WGPUChainedStruct,
    pub outOfMemory: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnBufferDescriptorErrorInfoFromWireClient"]
        [::core::mem::size_of::<WGPUDawnBufferDescriptorErrorInfoFromWireClient>() - 24usize];
    ["Alignment of WGPUDawnBufferDescriptorErrorInfoFromWireClient"]
        [::core::mem::align_of::<WGPUDawnBufferDescriptorErrorInfoFromWireClient>() - 8usize];
    ["Offset of field: WGPUDawnBufferDescriptorErrorInfoFromWireClient::chain"]
        [::core::mem::offset_of!(WGPUDawnBufferDescriptorErrorInfoFromWireClient, chain) - 0usize];
    ["Offset of field: WGPUDawnBufferDescriptorErrorInfoFromWireClient::outOfMemory"][::core::mem::offset_of!(
        WGPUDawnBufferDescriptorErrorInfoFromWireClient,
        outOfMemory
    ) - 16usize];
};
impl Default for WGPUDawnBufferDescriptorErrorInfoFromWireClient {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnCacheDeviceDescriptor {
    pub chain: WGPUChainedStruct,
    pub isolationKey: WGPUStringView,
    pub loadDataFunction: WGPUDawnLoadCacheDataFunction,
    pub storeDataFunction: WGPUDawnStoreCacheDataFunction,
    pub functionUserdata: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnCacheDeviceDescriptor"]
        [::core::mem::size_of::<WGPUDawnCacheDeviceDescriptor>() - 56usize];
    ["Alignment of WGPUDawnCacheDeviceDescriptor"]
        [::core::mem::align_of::<WGPUDawnCacheDeviceDescriptor>() - 8usize];
    ["Offset of field: WGPUDawnCacheDeviceDescriptor::chain"]
        [::core::mem::offset_of!(WGPUDawnCacheDeviceDescriptor, chain) - 0usize];
    ["Offset of field: WGPUDawnCacheDeviceDescriptor::isolationKey"]
        [::core::mem::offset_of!(WGPUDawnCacheDeviceDescriptor, isolationKey) - 16usize];
    ["Offset of field: WGPUDawnCacheDeviceDescriptor::loadDataFunction"]
        [::core::mem::offset_of!(WGPUDawnCacheDeviceDescriptor, loadDataFunction) - 32usize];
    ["Offset of field: WGPUDawnCacheDeviceDescriptor::storeDataFunction"]
        [::core::mem::offset_of!(WGPUDawnCacheDeviceDescriptor, storeDataFunction) - 40usize];
    ["Offset of field: WGPUDawnCacheDeviceDescriptor::functionUserdata"]
        [::core::mem::offset_of!(WGPUDawnCacheDeviceDescriptor, functionUserdata) - 48usize];
};
impl Default for WGPUDawnCacheDeviceDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnCompilationMessageUtf16 {
    pub chain: WGPUChainedStruct,
    pub linePos: u64,
    pub offset: u64,
    pub length: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnCompilationMessageUtf16"]
        [::core::mem::size_of::<WGPUDawnCompilationMessageUtf16>() - 40usize];
    ["Alignment of WGPUDawnCompilationMessageUtf16"]
        [::core::mem::align_of::<WGPUDawnCompilationMessageUtf16>() - 8usize];
    ["Offset of field: WGPUDawnCompilationMessageUtf16::chain"]
        [::core::mem::offset_of!(WGPUDawnCompilationMessageUtf16, chain) - 0usize];
    ["Offset of field: WGPUDawnCompilationMessageUtf16::linePos"]
        [::core::mem::offset_of!(WGPUDawnCompilationMessageUtf16, linePos) - 16usize];
    ["Offset of field: WGPUDawnCompilationMessageUtf16::offset"]
        [::core::mem::offset_of!(WGPUDawnCompilationMessageUtf16, offset) - 24usize];
    ["Offset of field: WGPUDawnCompilationMessageUtf16::length"]
        [::core::mem::offset_of!(WGPUDawnCompilationMessageUtf16, length) - 32usize];
};
impl Default for WGPUDawnCompilationMessageUtf16 {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnDeviceAllocatorControl {
    pub chain: WGPUChainedStruct,
    pub allocatorHeapBlockSize: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnDeviceAllocatorControl"]
        [::core::mem::size_of::<WGPUDawnDeviceAllocatorControl>() - 24usize];
    ["Alignment of WGPUDawnDeviceAllocatorControl"]
        [::core::mem::align_of::<WGPUDawnDeviceAllocatorControl>() - 8usize];
    ["Offset of field: WGPUDawnDeviceAllocatorControl::chain"]
        [::core::mem::offset_of!(WGPUDawnDeviceAllocatorControl, chain) - 0usize];
    ["Offset of field: WGPUDawnDeviceAllocatorControl::allocatorHeapBlockSize"]
        [::core::mem::offset_of!(WGPUDawnDeviceAllocatorControl, allocatorHeapBlockSize) - 16usize];
};
impl Default for WGPUDawnDeviceAllocatorControl {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnDrmFormatProperties {
    pub modifier: u64,
    pub modifierPlaneCount: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnDrmFormatProperties"]
        [::core::mem::size_of::<WGPUDawnDrmFormatProperties>() - 16usize];
    ["Alignment of WGPUDawnDrmFormatProperties"]
        [::core::mem::align_of::<WGPUDawnDrmFormatProperties>() - 8usize];
    ["Offset of field: WGPUDawnDrmFormatProperties::modifier"]
        [::core::mem::offset_of!(WGPUDawnDrmFormatProperties, modifier) - 0usize];
    ["Offset of field: WGPUDawnDrmFormatProperties::modifierPlaneCount"]
        [::core::mem::offset_of!(WGPUDawnDrmFormatProperties, modifierPlaneCount) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnEncoderInternalUsageDescriptor {
    pub chain: WGPUChainedStruct,
    pub useInternalUsages: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnEncoderInternalUsageDescriptor"]
        [::core::mem::size_of::<WGPUDawnEncoderInternalUsageDescriptor>() - 24usize];
    ["Alignment of WGPUDawnEncoderInternalUsageDescriptor"]
        [::core::mem::align_of::<WGPUDawnEncoderInternalUsageDescriptor>() - 8usize];
    ["Offset of field: WGPUDawnEncoderInternalUsageDescriptor::chain"]
        [::core::mem::offset_of!(WGPUDawnEncoderInternalUsageDescriptor, chain) - 0usize];
    ["Offset of field: WGPUDawnEncoderInternalUsageDescriptor::useInternalUsages"][::core::mem::offset_of!(
        WGPUDawnEncoderInternalUsageDescriptor,
        useInternalUsages
    ) - 16usize];
};
impl Default for WGPUDawnEncoderInternalUsageDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnFakeBufferOOMForTesting {
    pub chain: WGPUChainedStruct,
    pub fakeOOMAtWireClientMap: WGPUBool,
    pub fakeOOMAtNativeMap: WGPUBool,
    pub fakeOOMAtDevice: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnFakeBufferOOMForTesting"]
        [::core::mem::size_of::<WGPUDawnFakeBufferOOMForTesting>() - 32usize];
    ["Alignment of WGPUDawnFakeBufferOOMForTesting"]
        [::core::mem::align_of::<WGPUDawnFakeBufferOOMForTesting>() - 8usize];
    ["Offset of field: WGPUDawnFakeBufferOOMForTesting::chain"]
        [::core::mem::offset_of!(WGPUDawnFakeBufferOOMForTesting, chain) - 0usize];
    ["Offset of field: WGPUDawnFakeBufferOOMForTesting::fakeOOMAtWireClientMap"][::core::mem::offset_of!(
        WGPUDawnFakeBufferOOMForTesting,
        fakeOOMAtWireClientMap
    ) - 16usize];
    ["Offset of field: WGPUDawnFakeBufferOOMForTesting::fakeOOMAtNativeMap"]
        [::core::mem::offset_of!(WGPUDawnFakeBufferOOMForTesting, fakeOOMAtNativeMap) - 20usize];
    ["Offset of field: WGPUDawnFakeBufferOOMForTesting::fakeOOMAtDevice"]
        [::core::mem::offset_of!(WGPUDawnFakeBufferOOMForTesting, fakeOOMAtDevice) - 24usize];
};
impl Default for WGPUDawnFakeBufferOOMForTesting {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnHostMappedPointerLimits {
    pub chain: WGPUChainedStruct,
    pub hostMappedPointerAlignment: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnHostMappedPointerLimits"]
        [::core::mem::size_of::<WGPUDawnHostMappedPointerLimits>() - 24usize];
    ["Alignment of WGPUDawnHostMappedPointerLimits"]
        [::core::mem::align_of::<WGPUDawnHostMappedPointerLimits>() - 8usize];
    ["Offset of field: WGPUDawnHostMappedPointerLimits::chain"]
        [::core::mem::offset_of!(WGPUDawnHostMappedPointerLimits, chain) - 0usize];
    ["Offset of field: WGPUDawnHostMappedPointerLimits::hostMappedPointerAlignment"][::core::mem::offset_of!(
        WGPUDawnHostMappedPointerLimits,
        hostMappedPointerAlignment
    ) - 16usize];
};
impl Default for WGPUDawnHostMappedPointerLimits {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnInjectedInvalidSType {
    pub chain: WGPUChainedStruct,
    pub invalidSType: WGPUSType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnInjectedInvalidSType"]
        [::core::mem::size_of::<WGPUDawnInjectedInvalidSType>() - 24usize];
    ["Alignment of WGPUDawnInjectedInvalidSType"]
        [::core::mem::align_of::<WGPUDawnInjectedInvalidSType>() - 8usize];
    ["Offset of field: WGPUDawnInjectedInvalidSType::chain"]
        [::core::mem::offset_of!(WGPUDawnInjectedInvalidSType, chain) - 0usize];
    ["Offset of field: WGPUDawnInjectedInvalidSType::invalidSType"]
        [::core::mem::offset_of!(WGPUDawnInjectedInvalidSType, invalidSType) - 16usize];
};
impl Default for WGPUDawnInjectedInvalidSType {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnRenderPassColorAttachmentRenderToSingleSampled {
    pub chain: WGPUChainedStruct,
    pub implicitSampleCount: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnRenderPassColorAttachmentRenderToSingleSampled"][::core::mem::size_of::<
        WGPUDawnRenderPassColorAttachmentRenderToSingleSampled,
    >() - 24usize];
    ["Alignment of WGPUDawnRenderPassColorAttachmentRenderToSingleSampled"][::core::mem::align_of::<
        WGPUDawnRenderPassColorAttachmentRenderToSingleSampled,
    >() - 8usize];
    ["Offset of field: WGPUDawnRenderPassColorAttachmentRenderToSingleSampled::chain"][::core::mem::offset_of!(
        WGPUDawnRenderPassColorAttachmentRenderToSingleSampled,
        chain
    ) - 0usize];
    ["Offset of field: WGPUDawnRenderPassColorAttachmentRenderToSingleSampled::implicitSampleCount"] [:: core :: mem :: offset_of ! (WGPUDawnRenderPassColorAttachmentRenderToSingleSampled , implicitSampleCount) - 16usize] ;
};
impl Default for WGPUDawnRenderPassColorAttachmentRenderToSingleSampled {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnShaderModuleSPIRVOptionsDescriptor {
    pub chain: WGPUChainedStruct,
    pub allowNonUniformDerivatives: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnShaderModuleSPIRVOptionsDescriptor"]
        [::core::mem::size_of::<WGPUDawnShaderModuleSPIRVOptionsDescriptor>() - 24usize];
    ["Alignment of WGPUDawnShaderModuleSPIRVOptionsDescriptor"]
        [::core::mem::align_of::<WGPUDawnShaderModuleSPIRVOptionsDescriptor>() - 8usize];
    ["Offset of field: WGPUDawnShaderModuleSPIRVOptionsDescriptor::chain"]
        [::core::mem::offset_of!(WGPUDawnShaderModuleSPIRVOptionsDescriptor, chain) - 0usize];
    ["Offset of field: WGPUDawnShaderModuleSPIRVOptionsDescriptor::allowNonUniformDerivatives"][::core::mem::offset_of!(
        WGPUDawnShaderModuleSPIRVOptionsDescriptor,
        allowNonUniformDerivatives
    )
        - 16usize];
};
impl Default for WGPUDawnShaderModuleSPIRVOptionsDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnTexelCopyBufferRowAlignmentLimits {
    pub chain: WGPUChainedStruct,
    pub minTexelCopyBufferRowAlignment: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnTexelCopyBufferRowAlignmentLimits"]
        [::core::mem::size_of::<WGPUDawnTexelCopyBufferRowAlignmentLimits>() - 24usize];
    ["Alignment of WGPUDawnTexelCopyBufferRowAlignmentLimits"]
        [::core::mem::align_of::<WGPUDawnTexelCopyBufferRowAlignmentLimits>() - 8usize];
    ["Offset of field: WGPUDawnTexelCopyBufferRowAlignmentLimits::chain"]
        [::core::mem::offset_of!(WGPUDawnTexelCopyBufferRowAlignmentLimits, chain) - 0usize];
    ["Offset of field: WGPUDawnTexelCopyBufferRowAlignmentLimits::minTexelCopyBufferRowAlignment"] [:: core :: mem :: offset_of ! (WGPUDawnTexelCopyBufferRowAlignmentLimits , minTexelCopyBufferRowAlignment) - 16usize] ;
};
impl Default for WGPUDawnTexelCopyBufferRowAlignmentLimits {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUDawnTextureInternalUsageDescriptor {
    pub chain: WGPUChainedStruct,
    pub internalUsage: WGPUTextureUsage,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnTextureInternalUsageDescriptor"]
        [::core::mem::size_of::<WGPUDawnTextureInternalUsageDescriptor>() - 24usize];
    ["Alignment of WGPUDawnTextureInternalUsageDescriptor"]
        [::core::mem::align_of::<WGPUDawnTextureInternalUsageDescriptor>() - 8usize];
    ["Offset of field: WGPUDawnTextureInternalUsageDescriptor::chain"]
        [::core::mem::offset_of!(WGPUDawnTextureInternalUsageDescriptor, chain) - 0usize];
    ["Offset of field: WGPUDawnTextureInternalUsageDescriptor::internalUsage"]
        [::core::mem::offset_of!(WGPUDawnTextureInternalUsageDescriptor, internalUsage) - 16usize];
};
impl Default for WGPUDawnTextureInternalUsageDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnTogglesDescriptor {
    pub chain: WGPUChainedStruct,
    pub enabledToggleCount: usize,
    pub enabledToggles: *const *const ::core::ffi::c_char,
    pub disabledToggleCount: usize,
    pub disabledToggles: *const *const ::core::ffi::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnTogglesDescriptor"]
        [::core::mem::size_of::<WGPUDawnTogglesDescriptor>() - 48usize];
    ["Alignment of WGPUDawnTogglesDescriptor"]
        [::core::mem::align_of::<WGPUDawnTogglesDescriptor>() - 8usize];
    ["Offset of field: WGPUDawnTogglesDescriptor::chain"]
        [::core::mem::offset_of!(WGPUDawnTogglesDescriptor, chain) - 0usize];
    ["Offset of field: WGPUDawnTogglesDescriptor::enabledToggleCount"]
        [::core::mem::offset_of!(WGPUDawnTogglesDescriptor, enabledToggleCount) - 16usize];
    ["Offset of field: WGPUDawnTogglesDescriptor::enabledToggles"]
        [::core::mem::offset_of!(WGPUDawnTogglesDescriptor, enabledToggles) - 24usize];
    ["Offset of field: WGPUDawnTogglesDescriptor::disabledToggleCount"]
        [::core::mem::offset_of!(WGPUDawnTogglesDescriptor, disabledToggleCount) - 32usize];
    ["Offset of field: WGPUDawnTogglesDescriptor::disabledToggles"]
        [::core::mem::offset_of!(WGPUDawnTogglesDescriptor, disabledToggles) - 40usize];
};
impl Default for WGPUDawnTogglesDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnWGSLBlocklist {
    pub chain: WGPUChainedStruct,
    pub blocklistedFeatureCount: usize,
    pub blocklistedFeatures: *const *const ::core::ffi::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnWGSLBlocklist"][::core::mem::size_of::<WGPUDawnWGSLBlocklist>() - 32usize];
    ["Alignment of WGPUDawnWGSLBlocklist"]
        [::core::mem::align_of::<WGPUDawnWGSLBlocklist>() - 8usize];
    ["Offset of field: WGPUDawnWGSLBlocklist::chain"]
        [::core::mem::offset_of!(WGPUDawnWGSLBlocklist, chain) - 0usize];
    ["Offset of field: WGPUDawnWGSLBlocklist::blocklistedFeatureCount"]
        [::core::mem::offset_of!(WGPUDawnWGSLBlocklist, blocklistedFeatureCount) - 16usize];
    ["Offset of field: WGPUDawnWGSLBlocklist::blocklistedFeatures"]
        [::core::mem::offset_of!(WGPUDawnWGSLBlocklist, blocklistedFeatures) - 24usize];
};
impl Default for WGPUDawnWGSLBlocklist {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnWireWGSLControl {
    pub chain: WGPUChainedStruct,
    pub enableExperimental: WGPUBool,
    pub enableUnsafe: WGPUBool,
    pub enableTesting: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnWireWGSLControl"]
        [::core::mem::size_of::<WGPUDawnWireWGSLControl>() - 32usize];
    ["Alignment of WGPUDawnWireWGSLControl"]
        [::core::mem::align_of::<WGPUDawnWireWGSLControl>() - 8usize];
    ["Offset of field: WGPUDawnWireWGSLControl::chain"]
        [::core::mem::offset_of!(WGPUDawnWireWGSLControl, chain) - 0usize];
    ["Offset of field: WGPUDawnWireWGSLControl::enableExperimental"]
        [::core::mem::offset_of!(WGPUDawnWireWGSLControl, enableExperimental) - 16usize];
    ["Offset of field: WGPUDawnWireWGSLControl::enableUnsafe"]
        [::core::mem::offset_of!(WGPUDawnWireWGSLControl, enableUnsafe) - 20usize];
    ["Offset of field: WGPUDawnWireWGSLControl::enableTesting"]
        [::core::mem::offset_of!(WGPUDawnWireWGSLControl, enableTesting) - 24usize];
};
impl Default for WGPUDawnWireWGSLControl {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUEmscriptenSurfaceSourceCanvasHTMLSelector {
    pub chain: WGPUChainedStruct,
    pub selector: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUEmscriptenSurfaceSourceCanvasHTMLSelector"]
        [::core::mem::size_of::<WGPUEmscriptenSurfaceSourceCanvasHTMLSelector>() - 32usize];
    ["Alignment of WGPUEmscriptenSurfaceSourceCanvasHTMLSelector"]
        [::core::mem::align_of::<WGPUEmscriptenSurfaceSourceCanvasHTMLSelector>() - 8usize];
    ["Offset of field: WGPUEmscriptenSurfaceSourceCanvasHTMLSelector::chain"]
        [::core::mem::offset_of!(WGPUEmscriptenSurfaceSourceCanvasHTMLSelector, chain) - 0usize];
    ["Offset of field: WGPUEmscriptenSurfaceSourceCanvasHTMLSelector::selector"][::core::mem::offset_of!(
        WGPUEmscriptenSurfaceSourceCanvasHTMLSelector,
        selector
    ) - 16usize];
};
impl Default for WGPUEmscriptenSurfaceSourceCanvasHTMLSelector {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUExtent2D {
    pub width: u32,
    pub height: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUExtent2D"][::core::mem::size_of::<WGPUExtent2D>() - 8usize];
    ["Alignment of WGPUExtent2D"][::core::mem::align_of::<WGPUExtent2D>() - 4usize];
    ["Offset of field: WGPUExtent2D::width"][::core::mem::offset_of!(WGPUExtent2D, width) - 0usize];
    ["Offset of field: WGPUExtent2D::height"]
        [::core::mem::offset_of!(WGPUExtent2D, height) - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUExtent3D {
    pub width: u32,
    pub height: u32,
    pub depthOrArrayLayers: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUExtent3D"][::core::mem::size_of::<WGPUExtent3D>() - 12usize];
    ["Alignment of WGPUExtent3D"][::core::mem::align_of::<WGPUExtent3D>() - 4usize];
    ["Offset of field: WGPUExtent3D::width"][::core::mem::offset_of!(WGPUExtent3D, width) - 0usize];
    ["Offset of field: WGPUExtent3D::height"]
        [::core::mem::offset_of!(WGPUExtent3D, height) - 4usize];
    ["Offset of field: WGPUExtent3D::depthOrArrayLayers"]
        [::core::mem::offset_of!(WGPUExtent3D, depthOrArrayLayers) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUExternalTextureBindingEntry {
    pub chain: WGPUChainedStruct,
    pub externalTexture: WGPUExternalTexture,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUExternalTextureBindingEntry"]
        [::core::mem::size_of::<WGPUExternalTextureBindingEntry>() - 24usize];
    ["Alignment of WGPUExternalTextureBindingEntry"]
        [::core::mem::align_of::<WGPUExternalTextureBindingEntry>() - 8usize];
    ["Offset of field: WGPUExternalTextureBindingEntry::chain"]
        [::core::mem::offset_of!(WGPUExternalTextureBindingEntry, chain) - 0usize];
    ["Offset of field: WGPUExternalTextureBindingEntry::externalTexture"]
        [::core::mem::offset_of!(WGPUExternalTextureBindingEntry, externalTexture) - 16usize];
};
impl Default for WGPUExternalTextureBindingEntry {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUExternalTextureBindingLayout {
    pub chain: WGPUChainedStruct,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUExternalTextureBindingLayout"]
        [::core::mem::size_of::<WGPUExternalTextureBindingLayout>() - 16usize];
    ["Alignment of WGPUExternalTextureBindingLayout"]
        [::core::mem::align_of::<WGPUExternalTextureBindingLayout>() - 8usize];
    ["Offset of field: WGPUExternalTextureBindingLayout::chain"]
        [::core::mem::offset_of!(WGPUExternalTextureBindingLayout, chain) - 0usize];
};
impl Default for WGPUExternalTextureBindingLayout {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUFuture {
    pub id: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUFuture"][::core::mem::size_of::<WGPUFuture>() - 8usize];
    ["Alignment of WGPUFuture"][::core::mem::align_of::<WGPUFuture>() - 8usize];
    ["Offset of field: WGPUFuture::id"][::core::mem::offset_of!(WGPUFuture, id) - 0usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUInstanceCapabilities {
    pub nextInChain: *mut WGPUChainedStruct,
    pub timedWaitAnyEnable: WGPUBool,
    pub timedWaitAnyMaxCount: usize,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUInstanceCapabilities"]
        [::core::mem::size_of::<WGPUInstanceCapabilities>() - 24usize];
    ["Alignment of WGPUInstanceCapabilities"]
        [::core::mem::align_of::<WGPUInstanceCapabilities>() - 8usize];
    ["Offset of field: WGPUInstanceCapabilities::nextInChain"]
        [::core::mem::offset_of!(WGPUInstanceCapabilities, nextInChain) - 0usize];
    ["Offset of field: WGPUInstanceCapabilities::timedWaitAnyEnable"]
        [::core::mem::offset_of!(WGPUInstanceCapabilities, timedWaitAnyEnable) - 8usize];
    ["Offset of field: WGPUInstanceCapabilities::timedWaitAnyMaxCount"]
        [::core::mem::offset_of!(WGPUInstanceCapabilities, timedWaitAnyMaxCount) - 16usize];
};
impl Default for WGPUInstanceCapabilities {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUINTERNAL_HAVE_EMDAWNWEBGPU_HEADER {
    pub unused: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUINTERNAL_HAVE_EMDAWNWEBGPU_HEADER"]
        [::core::mem::size_of::<WGPUINTERNAL_HAVE_EMDAWNWEBGPU_HEADER>() - 4usize];
    ["Alignment of WGPUINTERNAL_HAVE_EMDAWNWEBGPU_HEADER"]
        [::core::mem::align_of::<WGPUINTERNAL_HAVE_EMDAWNWEBGPU_HEADER>() - 4usize];
    ["Offset of field: WGPUINTERNAL_HAVE_EMDAWNWEBGPU_HEADER::unused"]
        [::core::mem::offset_of!(WGPUINTERNAL_HAVE_EMDAWNWEBGPU_HEADER, unused) - 0usize];
};
#[repr(C)]
pub struct WGPUMemoryHeapInfo {
    pub properties: WGPUHeapProperty,
    pub size: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUMemoryHeapInfo"][::core::mem::size_of::<WGPUMemoryHeapInfo>() - 16usize];
    ["Alignment of WGPUMemoryHeapInfo"][::core::mem::align_of::<WGPUMemoryHeapInfo>() - 8usize];
    ["Offset of field: WGPUMemoryHeapInfo::properties"]
        [::core::mem::offset_of!(WGPUMemoryHeapInfo, properties) - 0usize];
    ["Offset of field: WGPUMemoryHeapInfo::size"]
        [::core::mem::offset_of!(WGPUMemoryHeapInfo, size) - 8usize];
};
impl Default for WGPUMemoryHeapInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUMultisampleState {
    pub nextInChain: *mut WGPUChainedStruct,
    pub count: u32,
    pub mask: u32,
    pub alphaToCoverageEnabled: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUMultisampleState"][::core::mem::size_of::<WGPUMultisampleState>() - 24usize];
    ["Alignment of WGPUMultisampleState"][::core::mem::align_of::<WGPUMultisampleState>() - 8usize];
    ["Offset of field: WGPUMultisampleState::nextInChain"]
        [::core::mem::offset_of!(WGPUMultisampleState, nextInChain) - 0usize];
    ["Offset of field: WGPUMultisampleState::count"]
        [::core::mem::offset_of!(WGPUMultisampleState, count) - 8usize];
    ["Offset of field: WGPUMultisampleState::mask"]
        [::core::mem::offset_of!(WGPUMultisampleState, mask) - 12usize];
    ["Offset of field: WGPUMultisampleState::alphaToCoverageEnabled"]
        [::core::mem::offset_of!(WGPUMultisampleState, alphaToCoverageEnabled) - 16usize];
};
impl Default for WGPUMultisampleState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUOrigin2D {
    pub x: u32,
    pub y: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUOrigin2D"][::core::mem::size_of::<WGPUOrigin2D>() - 8usize];
    ["Alignment of WGPUOrigin2D"][::core::mem::align_of::<WGPUOrigin2D>() - 4usize];
    ["Offset of field: WGPUOrigin2D::x"][::core::mem::offset_of!(WGPUOrigin2D, x) - 0usize];
    ["Offset of field: WGPUOrigin2D::y"][::core::mem::offset_of!(WGPUOrigin2D, y) - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUOrigin3D {
    pub x: u32,
    pub y: u32,
    pub z: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUOrigin3D"][::core::mem::size_of::<WGPUOrigin3D>() - 12usize];
    ["Alignment of WGPUOrigin3D"][::core::mem::align_of::<WGPUOrigin3D>() - 4usize];
    ["Offset of field: WGPUOrigin3D::x"][::core::mem::offset_of!(WGPUOrigin3D, x) - 0usize];
    ["Offset of field: WGPUOrigin3D::y"][::core::mem::offset_of!(WGPUOrigin3D, y) - 4usize];
    ["Offset of field: WGPUOrigin3D::z"][::core::mem::offset_of!(WGPUOrigin3D, z) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPassTimestampWrites {
    pub nextInChain: *mut WGPUChainedStruct,
    pub querySet: WGPUQuerySet,
    pub beginningOfPassWriteIndex: u32,
    pub endOfPassWriteIndex: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUPassTimestampWrites"]
        [::core::mem::size_of::<WGPUPassTimestampWrites>() - 24usize];
    ["Alignment of WGPUPassTimestampWrites"]
        [::core::mem::align_of::<WGPUPassTimestampWrites>() - 8usize];
    ["Offset of field: WGPUPassTimestampWrites::nextInChain"]
        [::core::mem::offset_of!(WGPUPassTimestampWrites, nextInChain) - 0usize];
    ["Offset of field: WGPUPassTimestampWrites::querySet"]
        [::core::mem::offset_of!(WGPUPassTimestampWrites, querySet) - 8usize];
    ["Offset of field: WGPUPassTimestampWrites::beginningOfPassWriteIndex"]
        [::core::mem::offset_of!(WGPUPassTimestampWrites, beginningOfPassWriteIndex) - 16usize];
    ["Offset of field: WGPUPassTimestampWrites::endOfPassWriteIndex"]
        [::core::mem::offset_of!(WGPUPassTimestampWrites, endOfPassWriteIndex) - 20usize];
};
impl Default for WGPUPassTimestampWrites {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPipelineLayoutStorageAttachment {
    pub nextInChain: *mut WGPUChainedStruct,
    pub offset: u64,
    pub format: WGPUTextureFormat,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUPipelineLayoutStorageAttachment"]
        [::core::mem::size_of::<WGPUPipelineLayoutStorageAttachment>() - 24usize];
    ["Alignment of WGPUPipelineLayoutStorageAttachment"]
        [::core::mem::align_of::<WGPUPipelineLayoutStorageAttachment>() - 8usize];
    ["Offset of field: WGPUPipelineLayoutStorageAttachment::nextInChain"]
        [::core::mem::offset_of!(WGPUPipelineLayoutStorageAttachment, nextInChain) - 0usize];
    ["Offset of field: WGPUPipelineLayoutStorageAttachment::offset"]
        [::core::mem::offset_of!(WGPUPipelineLayoutStorageAttachment, offset) - 8usize];
    ["Offset of field: WGPUPipelineLayoutStorageAttachment::format"]
        [::core::mem::offset_of!(WGPUPipelineLayoutStorageAttachment, format) - 16usize];
};
impl Default for WGPUPipelineLayoutStorageAttachment {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPrimitiveState {
    pub nextInChain: *mut WGPUChainedStruct,
    pub topology: WGPUPrimitiveTopology,
    pub stripIndexFormat: WGPUIndexFormat,
    pub frontFace: WGPUFrontFace,
    pub cullMode: WGPUCullMode,
    pub unclippedDepth: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUPrimitiveState"][::core::mem::size_of::<WGPUPrimitiveState>() - 32usize];
    ["Alignment of WGPUPrimitiveState"][::core::mem::align_of::<WGPUPrimitiveState>() - 8usize];
    ["Offset of field: WGPUPrimitiveState::nextInChain"]
        [::core::mem::offset_of!(WGPUPrimitiveState, nextInChain) - 0usize];
    ["Offset of field: WGPUPrimitiveState::topology"]
        [::core::mem::offset_of!(WGPUPrimitiveState, topology) - 8usize];
    ["Offset of field: WGPUPrimitiveState::stripIndexFormat"]
        [::core::mem::offset_of!(WGPUPrimitiveState, stripIndexFormat) - 12usize];
    ["Offset of field: WGPUPrimitiveState::frontFace"]
        [::core::mem::offset_of!(WGPUPrimitiveState, frontFace) - 16usize];
    ["Offset of field: WGPUPrimitiveState::cullMode"]
        [::core::mem::offset_of!(WGPUPrimitiveState, cullMode) - 20usize];
    ["Offset of field: WGPUPrimitiveState::unclippedDepth"]
        [::core::mem::offset_of!(WGPUPrimitiveState, unclippedDepth) - 24usize];
};
impl Default for WGPUPrimitiveState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUQuerySetDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub type_: WGPUQueryType,
    pub count: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUQuerySetDescriptor"][::core::mem::size_of::<WGPUQuerySetDescriptor>() - 32usize];
    ["Alignment of WGPUQuerySetDescriptor"]
        [::core::mem::align_of::<WGPUQuerySetDescriptor>() - 8usize];
    ["Offset of field: WGPUQuerySetDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUQuerySetDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUQuerySetDescriptor::label"]
        [::core::mem::offset_of!(WGPUQuerySetDescriptor, label) - 8usize];
    ["Offset of field: WGPUQuerySetDescriptor::type_"]
        [::core::mem::offset_of!(WGPUQuerySetDescriptor, type_) - 24usize];
    ["Offset of field: WGPUQuerySetDescriptor::count"]
        [::core::mem::offset_of!(WGPUQuerySetDescriptor, count) - 28usize];
};
impl Default for WGPUQuerySetDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUQueueDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUQueueDescriptor"][::core::mem::size_of::<WGPUQueueDescriptor>() - 24usize];
    ["Alignment of WGPUQueueDescriptor"][::core::mem::align_of::<WGPUQueueDescriptor>() - 8usize];
    ["Offset of field: WGPUQueueDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUQueueDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUQueueDescriptor::label"]
        [::core::mem::offset_of!(WGPUQueueDescriptor, label) - 8usize];
};
impl Default for WGPUQueueDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURenderBundleDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderBundleDescriptor"]
        [::core::mem::size_of::<WGPURenderBundleDescriptor>() - 24usize];
    ["Alignment of WGPURenderBundleDescriptor"]
        [::core::mem::align_of::<WGPURenderBundleDescriptor>() - 8usize];
    ["Offset of field: WGPURenderBundleDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPURenderBundleDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPURenderBundleDescriptor::label"]
        [::core::mem::offset_of!(WGPURenderBundleDescriptor, label) - 8usize];
};
impl Default for WGPURenderBundleDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURenderBundleEncoderDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub colorFormatCount: usize,
    pub colorFormats: *const WGPUTextureFormat,
    pub depthStencilFormat: WGPUTextureFormat,
    pub sampleCount: u32,
    pub depthReadOnly: WGPUBool,
    pub stencilReadOnly: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderBundleEncoderDescriptor"]
        [::core::mem::size_of::<WGPURenderBundleEncoderDescriptor>() - 56usize];
    ["Alignment of WGPURenderBundleEncoderDescriptor"]
        [::core::mem::align_of::<WGPURenderBundleEncoderDescriptor>() - 8usize];
    ["Offset of field: WGPURenderBundleEncoderDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPURenderBundleEncoderDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPURenderBundleEncoderDescriptor::label"]
        [::core::mem::offset_of!(WGPURenderBundleEncoderDescriptor, label) - 8usize];
    ["Offset of field: WGPURenderBundleEncoderDescriptor::colorFormatCount"]
        [::core::mem::offset_of!(WGPURenderBundleEncoderDescriptor, colorFormatCount) - 24usize];
    ["Offset of field: WGPURenderBundleEncoderDescriptor::colorFormats"]
        [::core::mem::offset_of!(WGPURenderBundleEncoderDescriptor, colorFormats) - 32usize];
    ["Offset of field: WGPURenderBundleEncoderDescriptor::depthStencilFormat"]
        [::core::mem::offset_of!(WGPURenderBundleEncoderDescriptor, depthStencilFormat) - 40usize];
    ["Offset of field: WGPURenderBundleEncoderDescriptor::sampleCount"]
        [::core::mem::offset_of!(WGPURenderBundleEncoderDescriptor, sampleCount) - 44usize];
    ["Offset of field: WGPURenderBundleEncoderDescriptor::depthReadOnly"]
        [::core::mem::offset_of!(WGPURenderBundleEncoderDescriptor, depthReadOnly) - 48usize];
    ["Offset of field: WGPURenderBundleEncoderDescriptor::stencilReadOnly"]
        [::core::mem::offset_of!(WGPURenderBundleEncoderDescriptor, stencilReadOnly) - 52usize];
};
impl Default for WGPURenderBundleEncoderDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct WGPURenderPassDepthStencilAttachment {
    pub nextInChain: *mut WGPUChainedStruct,
    pub view: WGPUTextureView,
    pub depthLoadOp: WGPULoadOp,
    pub depthStoreOp: WGPUStoreOp,
    pub depthClearValue: f32,
    pub depthReadOnly: WGPUBool,
    pub stencilLoadOp: WGPULoadOp,
    pub stencilStoreOp: WGPUStoreOp,
    pub stencilClearValue: u32,
    pub stencilReadOnly: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderPassDepthStencilAttachment"]
        [::core::mem::size_of::<WGPURenderPassDepthStencilAttachment>() - 48usize];
    ["Alignment of WGPURenderPassDepthStencilAttachment"]
        [::core::mem::align_of::<WGPURenderPassDepthStencilAttachment>() - 8usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::nextInChain"]
        [::core::mem::offset_of!(WGPURenderPassDepthStencilAttachment, nextInChain) - 0usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::view"]
        [::core::mem::offset_of!(WGPURenderPassDepthStencilAttachment, view) - 8usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::depthLoadOp"]
        [::core::mem::offset_of!(WGPURenderPassDepthStencilAttachment, depthLoadOp) - 16usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::depthStoreOp"]
        [::core::mem::offset_of!(WGPURenderPassDepthStencilAttachment, depthStoreOp) - 20usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::depthClearValue"]
        [::core::mem::offset_of!(WGPURenderPassDepthStencilAttachment, depthClearValue) - 24usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::depthReadOnly"]
        [::core::mem::offset_of!(WGPURenderPassDepthStencilAttachment, depthReadOnly) - 28usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::stencilLoadOp"]
        [::core::mem::offset_of!(WGPURenderPassDepthStencilAttachment, stencilLoadOp) - 32usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::stencilStoreOp"]
        [::core::mem::offset_of!(WGPURenderPassDepthStencilAttachment, stencilStoreOp) - 36usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::stencilClearValue"][::core::mem::offset_of!(
        WGPURenderPassDepthStencilAttachment,
        stencilClearValue
    ) - 40usize];
    ["Offset of field: WGPURenderPassDepthStencilAttachment::stencilReadOnly"]
        [::core::mem::offset_of!(WGPURenderPassDepthStencilAttachment, stencilReadOnly) - 44usize];
};
impl Default for WGPURenderPassDepthStencilAttachment {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURenderPassDescriptorExpandResolveRect {
    pub chain: WGPUChainedStruct,
    pub x: u32,
    pub y: u32,
    pub width: u32,
    pub height: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderPassDescriptorExpandResolveRect"]
        [::core::mem::size_of::<WGPURenderPassDescriptorExpandResolveRect>() - 32usize];
    ["Alignment of WGPURenderPassDescriptorExpandResolveRect"]
        [::core::mem::align_of::<WGPURenderPassDescriptorExpandResolveRect>() - 8usize];
    ["Offset of field: WGPURenderPassDescriptorExpandResolveRect::chain"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorExpandResolveRect, chain) - 0usize];
    ["Offset of field: WGPURenderPassDescriptorExpandResolveRect::x"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorExpandResolveRect, x) - 16usize];
    ["Offset of field: WGPURenderPassDescriptorExpandResolveRect::y"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorExpandResolveRect, y) - 20usize];
    ["Offset of field: WGPURenderPassDescriptorExpandResolveRect::width"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorExpandResolveRect, width) - 24usize];
    ["Offset of field: WGPURenderPassDescriptorExpandResolveRect::height"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorExpandResolveRect, height) - 28usize];
};
impl Default for WGPURenderPassDescriptorExpandResolveRect {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURenderPassDescriptorResolveRect {
    pub chain: WGPUChainedStruct,
    pub colorOffsetX: u32,
    pub colorOffsetY: u32,
    pub resolveOffsetX: u32,
    pub resolveOffsetY: u32,
    pub width: u32,
    pub height: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderPassDescriptorResolveRect"]
        [::core::mem::size_of::<WGPURenderPassDescriptorResolveRect>() - 40usize];
    ["Alignment of WGPURenderPassDescriptorResolveRect"]
        [::core::mem::align_of::<WGPURenderPassDescriptorResolveRect>() - 8usize];
    ["Offset of field: WGPURenderPassDescriptorResolveRect::chain"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorResolveRect, chain) - 0usize];
    ["Offset of field: WGPURenderPassDescriptorResolveRect::colorOffsetX"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorResolveRect, colorOffsetX) - 16usize];
    ["Offset of field: WGPURenderPassDescriptorResolveRect::colorOffsetY"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorResolveRect, colorOffsetY) - 20usize];
    ["Offset of field: WGPURenderPassDescriptorResolveRect::resolveOffsetX"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorResolveRect, resolveOffsetX) - 24usize];
    ["Offset of field: WGPURenderPassDescriptorResolveRect::resolveOffsetY"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorResolveRect, resolveOffsetY) - 28usize];
    ["Offset of field: WGPURenderPassDescriptorResolveRect::width"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorResolveRect, width) - 32usize];
    ["Offset of field: WGPURenderPassDescriptorResolveRect::height"]
        [::core::mem::offset_of!(WGPURenderPassDescriptorResolveRect, height) - 36usize];
};
impl Default for WGPURenderPassDescriptorResolveRect {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURenderPassMaxDrawCount {
    pub chain: WGPUChainedStruct,
    pub maxDrawCount: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderPassMaxDrawCount"]
        [::core::mem::size_of::<WGPURenderPassMaxDrawCount>() - 24usize];
    ["Alignment of WGPURenderPassMaxDrawCount"]
        [::core::mem::align_of::<WGPURenderPassMaxDrawCount>() - 8usize];
    ["Offset of field: WGPURenderPassMaxDrawCount::chain"]
        [::core::mem::offset_of!(WGPURenderPassMaxDrawCount, chain) - 0usize];
    ["Offset of field: WGPURenderPassMaxDrawCount::maxDrawCount"]
        [::core::mem::offset_of!(WGPURenderPassMaxDrawCount, maxDrawCount) - 16usize];
};
impl Default for WGPURenderPassMaxDrawCount {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURequestAdapterWebXROptions {
    pub chain: WGPUChainedStruct,
    pub xrCompatible: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURequestAdapterWebXROptions"]
        [::core::mem::size_of::<WGPURequestAdapterWebXROptions>() - 24usize];
    ["Alignment of WGPURequestAdapterWebXROptions"]
        [::core::mem::align_of::<WGPURequestAdapterWebXROptions>() - 8usize];
    ["Offset of field: WGPURequestAdapterWebXROptions::chain"]
        [::core::mem::offset_of!(WGPURequestAdapterWebXROptions, chain) - 0usize];
    ["Offset of field: WGPURequestAdapterWebXROptions::xrCompatible"]
        [::core::mem::offset_of!(WGPURequestAdapterWebXROptions, xrCompatible) - 16usize];
};
impl Default for WGPURequestAdapterWebXROptions {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSamplerBindingLayout {
    pub nextInChain: *mut WGPUChainedStruct,
    pub type_: WGPUSamplerBindingType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSamplerBindingLayout"]
        [::core::mem::size_of::<WGPUSamplerBindingLayout>() - 16usize];
    ["Alignment of WGPUSamplerBindingLayout"]
        [::core::mem::align_of::<WGPUSamplerBindingLayout>() - 8usize];
    ["Offset of field: WGPUSamplerBindingLayout::nextInChain"]
        [::core::mem::offset_of!(WGPUSamplerBindingLayout, nextInChain) - 0usize];
    ["Offset of field: WGPUSamplerBindingLayout::type_"]
        [::core::mem::offset_of!(WGPUSamplerBindingLayout, type_) - 8usize];
};
impl Default for WGPUSamplerBindingLayout {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUShaderModuleCompilationOptions {
    pub chain: WGPUChainedStruct,
    pub strictMath: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUShaderModuleCompilationOptions"]
        [::core::mem::size_of::<WGPUShaderModuleCompilationOptions>() - 24usize];
    ["Alignment of WGPUShaderModuleCompilationOptions"]
        [::core::mem::align_of::<WGPUShaderModuleCompilationOptions>() - 8usize];
    ["Offset of field: WGPUShaderModuleCompilationOptions::chain"]
        [::core::mem::offset_of!(WGPUShaderModuleCompilationOptions, chain) - 0usize];
    ["Offset of field: WGPUShaderModuleCompilationOptions::strictMath"]
        [::core::mem::offset_of!(WGPUShaderModuleCompilationOptions, strictMath) - 16usize];
};
impl Default for WGPUShaderModuleCompilationOptions {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUShaderSourceSPIRV {
    pub chain: WGPUChainedStruct,
    pub codeSize: u32,
    pub code: *const u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUShaderSourceSPIRV"][::core::mem::size_of::<WGPUShaderSourceSPIRV>() - 32usize];
    ["Alignment of WGPUShaderSourceSPIRV"]
        [::core::mem::align_of::<WGPUShaderSourceSPIRV>() - 8usize];
    ["Offset of field: WGPUShaderSourceSPIRV::chain"]
        [::core::mem::offset_of!(WGPUShaderSourceSPIRV, chain) - 0usize];
    ["Offset of field: WGPUShaderSourceSPIRV::codeSize"]
        [::core::mem::offset_of!(WGPUShaderSourceSPIRV, codeSize) - 16usize];
    ["Offset of field: WGPUShaderSourceSPIRV::code"]
        [::core::mem::offset_of!(WGPUShaderSourceSPIRV, code) - 24usize];
};
impl Default for WGPUShaderSourceSPIRV {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUShaderSourceWGSL {
    pub chain: WGPUChainedStruct,
    pub code: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUShaderSourceWGSL"][::core::mem::size_of::<WGPUShaderSourceWGSL>() - 32usize];
    ["Alignment of WGPUShaderSourceWGSL"][::core::mem::align_of::<WGPUShaderSourceWGSL>() - 8usize];
    ["Offset of field: WGPUShaderSourceWGSL::chain"]
        [::core::mem::offset_of!(WGPUShaderSourceWGSL, chain) - 0usize];
    ["Offset of field: WGPUShaderSourceWGSL::code"]
        [::core::mem::offset_of!(WGPUShaderSourceWGSL, code) - 16usize];
};
impl Default for WGPUShaderSourceWGSL {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedBufferMemoryBeginAccessDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub initialized: WGPUBool,
    pub fenceCount: usize,
    pub fences: *const WGPUSharedFence,
    pub signaledValues: *const u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedBufferMemoryBeginAccessDescriptor"]
        [::core::mem::size_of::<WGPUSharedBufferMemoryBeginAccessDescriptor>() - 40usize];
    ["Alignment of WGPUSharedBufferMemoryBeginAccessDescriptor"]
        [::core::mem::align_of::<WGPUSharedBufferMemoryBeginAccessDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedBufferMemoryBeginAccessDescriptor::nextInChain"][::core::mem::offset_of!(
        WGPUSharedBufferMemoryBeginAccessDescriptor,
        nextInChain
    ) - 0usize];
    ["Offset of field: WGPUSharedBufferMemoryBeginAccessDescriptor::initialized"][::core::mem::offset_of!(
        WGPUSharedBufferMemoryBeginAccessDescriptor,
        initialized
    ) - 8usize];
    ["Offset of field: WGPUSharedBufferMemoryBeginAccessDescriptor::fenceCount"][::core::mem::offset_of!(
        WGPUSharedBufferMemoryBeginAccessDescriptor,
        fenceCount
    ) - 16usize];
    ["Offset of field: WGPUSharedBufferMemoryBeginAccessDescriptor::fences"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryBeginAccessDescriptor, fences) - 24usize];
    ["Offset of field: WGPUSharedBufferMemoryBeginAccessDescriptor::signaledValues"][::core::mem::offset_of!(
        WGPUSharedBufferMemoryBeginAccessDescriptor,
        signaledValues
    ) - 32usize];
};
impl Default for WGPUSharedBufferMemoryBeginAccessDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedBufferMemoryDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedBufferMemoryDescriptor"]
        [::core::mem::size_of::<WGPUSharedBufferMemoryDescriptor>() - 24usize];
    ["Alignment of WGPUSharedBufferMemoryDescriptor"]
        [::core::mem::align_of::<WGPUSharedBufferMemoryDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedBufferMemoryDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUSharedBufferMemoryDescriptor::label"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryDescriptor, label) - 8usize];
};
impl Default for WGPUSharedBufferMemoryDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedBufferMemoryEndAccessState {
    pub nextInChain: *mut WGPUChainedStruct,
    pub initialized: WGPUBool,
    pub fenceCount: usize,
    pub fences: *const WGPUSharedFence,
    pub signaledValues: *const u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedBufferMemoryEndAccessState"]
        [::core::mem::size_of::<WGPUSharedBufferMemoryEndAccessState>() - 40usize];
    ["Alignment of WGPUSharedBufferMemoryEndAccessState"]
        [::core::mem::align_of::<WGPUSharedBufferMemoryEndAccessState>() - 8usize];
    ["Offset of field: WGPUSharedBufferMemoryEndAccessState::nextInChain"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryEndAccessState, nextInChain) - 0usize];
    ["Offset of field: WGPUSharedBufferMemoryEndAccessState::initialized"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryEndAccessState, initialized) - 8usize];
    ["Offset of field: WGPUSharedBufferMemoryEndAccessState::fenceCount"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryEndAccessState, fenceCount) - 16usize];
    ["Offset of field: WGPUSharedBufferMemoryEndAccessState::fences"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryEndAccessState, fences) - 24usize];
    ["Offset of field: WGPUSharedBufferMemoryEndAccessState::signaledValues"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryEndAccessState, signaledValues) - 32usize];
};
impl Default for WGPUSharedBufferMemoryEndAccessState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUSharedBufferMemoryProperties {
    pub nextInChain: *mut WGPUChainedStruct,
    pub usage: WGPUBufferUsage,
    pub size: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedBufferMemoryProperties"]
        [::core::mem::size_of::<WGPUSharedBufferMemoryProperties>() - 24usize];
    ["Alignment of WGPUSharedBufferMemoryProperties"]
        [::core::mem::align_of::<WGPUSharedBufferMemoryProperties>() - 8usize];
    ["Offset of field: WGPUSharedBufferMemoryProperties::nextInChain"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryProperties, nextInChain) - 0usize];
    ["Offset of field: WGPUSharedBufferMemoryProperties::usage"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryProperties, usage) - 8usize];
    ["Offset of field: WGPUSharedBufferMemoryProperties::size"]
        [::core::mem::offset_of!(WGPUSharedBufferMemoryProperties, size) - 16usize];
};
impl Default for WGPUSharedBufferMemoryProperties {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceDXGISharedHandleDescriptor {
    pub chain: WGPUChainedStruct,
    pub handle: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceDXGISharedHandleDescriptor"]
        [::core::mem::size_of::<WGPUSharedFenceDXGISharedHandleDescriptor>() - 24usize];
    ["Alignment of WGPUSharedFenceDXGISharedHandleDescriptor"]
        [::core::mem::align_of::<WGPUSharedFenceDXGISharedHandleDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedFenceDXGISharedHandleDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceDXGISharedHandleDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceDXGISharedHandleDescriptor::handle"]
        [::core::mem::offset_of!(WGPUSharedFenceDXGISharedHandleDescriptor, handle) - 16usize];
};
impl Default for WGPUSharedFenceDXGISharedHandleDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceDXGISharedHandleExportInfo {
    pub chain: WGPUChainedStruct,
    pub handle: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceDXGISharedHandleExportInfo"]
        [::core::mem::size_of::<WGPUSharedFenceDXGISharedHandleExportInfo>() - 24usize];
    ["Alignment of WGPUSharedFenceDXGISharedHandleExportInfo"]
        [::core::mem::align_of::<WGPUSharedFenceDXGISharedHandleExportInfo>() - 8usize];
    ["Offset of field: WGPUSharedFenceDXGISharedHandleExportInfo::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceDXGISharedHandleExportInfo, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceDXGISharedHandleExportInfo::handle"]
        [::core::mem::offset_of!(WGPUSharedFenceDXGISharedHandleExportInfo, handle) - 16usize];
};
impl Default for WGPUSharedFenceDXGISharedHandleExportInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceEGLSyncDescriptor {
    pub chain: WGPUChainedStruct,
    pub sync: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceEGLSyncDescriptor"]
        [::core::mem::size_of::<WGPUSharedFenceEGLSyncDescriptor>() - 24usize];
    ["Alignment of WGPUSharedFenceEGLSyncDescriptor"]
        [::core::mem::align_of::<WGPUSharedFenceEGLSyncDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedFenceEGLSyncDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceEGLSyncDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceEGLSyncDescriptor::sync"]
        [::core::mem::offset_of!(WGPUSharedFenceEGLSyncDescriptor, sync) - 16usize];
};
impl Default for WGPUSharedFenceEGLSyncDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceEGLSyncExportInfo {
    pub chain: WGPUChainedStruct,
    pub sync: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceEGLSyncExportInfo"]
        [::core::mem::size_of::<WGPUSharedFenceEGLSyncExportInfo>() - 24usize];
    ["Alignment of WGPUSharedFenceEGLSyncExportInfo"]
        [::core::mem::align_of::<WGPUSharedFenceEGLSyncExportInfo>() - 8usize];
    ["Offset of field: WGPUSharedFenceEGLSyncExportInfo::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceEGLSyncExportInfo, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceEGLSyncExportInfo::sync"]
        [::core::mem::offset_of!(WGPUSharedFenceEGLSyncExportInfo, sync) - 16usize];
};
impl Default for WGPUSharedFenceEGLSyncExportInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceMTLSharedEventDescriptor {
    pub chain: WGPUChainedStruct,
    pub sharedEvent: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceMTLSharedEventDescriptor"]
        [::core::mem::size_of::<WGPUSharedFenceMTLSharedEventDescriptor>() - 24usize];
    ["Alignment of WGPUSharedFenceMTLSharedEventDescriptor"]
        [::core::mem::align_of::<WGPUSharedFenceMTLSharedEventDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedFenceMTLSharedEventDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceMTLSharedEventDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceMTLSharedEventDescriptor::sharedEvent"]
        [::core::mem::offset_of!(WGPUSharedFenceMTLSharedEventDescriptor, sharedEvent) - 16usize];
};
impl Default for WGPUSharedFenceMTLSharedEventDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceMTLSharedEventExportInfo {
    pub chain: WGPUChainedStruct,
    pub sharedEvent: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceMTLSharedEventExportInfo"]
        [::core::mem::size_of::<WGPUSharedFenceMTLSharedEventExportInfo>() - 24usize];
    ["Alignment of WGPUSharedFenceMTLSharedEventExportInfo"]
        [::core::mem::align_of::<WGPUSharedFenceMTLSharedEventExportInfo>() - 8usize];
    ["Offset of field: WGPUSharedFenceMTLSharedEventExportInfo::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceMTLSharedEventExportInfo, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceMTLSharedEventExportInfo::sharedEvent"]
        [::core::mem::offset_of!(WGPUSharedFenceMTLSharedEventExportInfo, sharedEvent) - 16usize];
};
impl Default for WGPUSharedFenceMTLSharedEventExportInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceSyncFDDescriptor {
    pub chain: WGPUChainedStruct,
    pub handle: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceSyncFDDescriptor"]
        [::core::mem::size_of::<WGPUSharedFenceSyncFDDescriptor>() - 24usize];
    ["Alignment of WGPUSharedFenceSyncFDDescriptor"]
        [::core::mem::align_of::<WGPUSharedFenceSyncFDDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedFenceSyncFDDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceSyncFDDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceSyncFDDescriptor::handle"]
        [::core::mem::offset_of!(WGPUSharedFenceSyncFDDescriptor, handle) - 16usize];
};
impl Default for WGPUSharedFenceSyncFDDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceSyncFDExportInfo {
    pub chain: WGPUChainedStruct,
    pub handle: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceSyncFDExportInfo"]
        [::core::mem::size_of::<WGPUSharedFenceSyncFDExportInfo>() - 24usize];
    ["Alignment of WGPUSharedFenceSyncFDExportInfo"]
        [::core::mem::align_of::<WGPUSharedFenceSyncFDExportInfo>() - 8usize];
    ["Offset of field: WGPUSharedFenceSyncFDExportInfo::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceSyncFDExportInfo, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceSyncFDExportInfo::handle"]
        [::core::mem::offset_of!(WGPUSharedFenceSyncFDExportInfo, handle) - 16usize];
};
impl Default for WGPUSharedFenceSyncFDExportInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor {
    pub chain: WGPUChainedStruct,
    pub handle: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor"]
        [::core::mem::size_of::<WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor>() - 24usize];
    ["Alignment of WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor"]
        [::core::mem::align_of::<WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor::handle"]
        [::core::mem::offset_of!(WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor, handle) - 16usize];
};
impl Default for WGPUSharedFenceVkSemaphoreOpaqueFDDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo {
    pub chain: WGPUChainedStruct,
    pub handle: ::core::ffi::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo"]
        [::core::mem::size_of::<WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo>() - 24usize];
    ["Alignment of WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo"]
        [::core::mem::align_of::<WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo>() - 8usize];
    ["Offset of field: WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo::handle"]
        [::core::mem::offset_of!(WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo, handle) - 16usize];
};
impl Default for WGPUSharedFenceVkSemaphoreOpaqueFDExportInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceVkSemaphoreZirconHandleDescriptor {
    pub chain: WGPUChainedStruct,
    pub handle: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceVkSemaphoreZirconHandleDescriptor"]
        [::core::mem::size_of::<WGPUSharedFenceVkSemaphoreZirconHandleDescriptor>() - 24usize];
    ["Alignment of WGPUSharedFenceVkSemaphoreZirconHandleDescriptor"]
        [::core::mem::align_of::<WGPUSharedFenceVkSemaphoreZirconHandleDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedFenceVkSemaphoreZirconHandleDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceVkSemaphoreZirconHandleDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceVkSemaphoreZirconHandleDescriptor::handle"][::core::mem::offset_of!(
        WGPUSharedFenceVkSemaphoreZirconHandleDescriptor,
        handle
    ) - 16usize];
};
impl Default for WGPUSharedFenceVkSemaphoreZirconHandleDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceVkSemaphoreZirconHandleExportInfo {
    pub chain: WGPUChainedStruct,
    pub handle: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceVkSemaphoreZirconHandleExportInfo"]
        [::core::mem::size_of::<WGPUSharedFenceVkSemaphoreZirconHandleExportInfo>() - 24usize];
    ["Alignment of WGPUSharedFenceVkSemaphoreZirconHandleExportInfo"]
        [::core::mem::align_of::<WGPUSharedFenceVkSemaphoreZirconHandleExportInfo>() - 8usize];
    ["Offset of field: WGPUSharedFenceVkSemaphoreZirconHandleExportInfo::chain"]
        [::core::mem::offset_of!(WGPUSharedFenceVkSemaphoreZirconHandleExportInfo, chain) - 0usize];
    ["Offset of field: WGPUSharedFenceVkSemaphoreZirconHandleExportInfo::handle"][::core::mem::offset_of!(
        WGPUSharedFenceVkSemaphoreZirconHandleExportInfo,
        handle
    ) - 16usize];
};
impl Default for WGPUSharedFenceVkSemaphoreZirconHandleExportInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryAHardwareBufferDescriptor {
    pub chain: WGPUChainedStruct,
    pub handle: *mut ::core::ffi::c_void,
    pub useExternalFormat: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryAHardwareBufferDescriptor"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryAHardwareBufferDescriptor>() - 32usize];
    ["Alignment of WGPUSharedTextureMemoryAHardwareBufferDescriptor"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryAHardwareBufferDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryAHardwareBufferDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryAHardwareBufferDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryAHardwareBufferDescriptor::handle"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryAHardwareBufferDescriptor,
        handle
    ) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryAHardwareBufferDescriptor::useExternalFormat"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryAHardwareBufferDescriptor,
        useExternalFormat
    )
        - 24usize];
};
impl Default for WGPUSharedTextureMemoryAHardwareBufferDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryD3DSwapchainBeginState {
    pub chain: WGPUChainedStruct,
    pub isSwapchain: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryD3DSwapchainBeginState"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryD3DSwapchainBeginState>() - 24usize];
    ["Alignment of WGPUSharedTextureMemoryD3DSwapchainBeginState"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryD3DSwapchainBeginState>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryD3DSwapchainBeginState::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryD3DSwapchainBeginState, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryD3DSwapchainBeginState::isSwapchain"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryD3DSwapchainBeginState,
        isSwapchain
    ) - 16usize];
};
impl Default for WGPUSharedTextureMemoryD3DSwapchainBeginState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryDmaBufPlane {
    pub fd: ::core::ffi::c_int,
    pub offset: u64,
    pub stride: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryDmaBufPlane"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryDmaBufPlane>() - 24usize];
    ["Alignment of WGPUSharedTextureMemoryDmaBufPlane"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryDmaBufPlane>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryDmaBufPlane::fd"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDmaBufPlane, fd) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryDmaBufPlane::offset"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDmaBufPlane, offset) - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryDmaBufPlane::stride"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDmaBufPlane, stride) - 16usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryDXGISharedHandleDescriptor {
    pub chain: WGPUChainedStruct,
    pub handle: *mut ::core::ffi::c_void,
    pub useKeyedMutex: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryDXGISharedHandleDescriptor"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryDXGISharedHandleDescriptor>() - 32usize];
    ["Alignment of WGPUSharedTextureMemoryDXGISharedHandleDescriptor"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryDXGISharedHandleDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryDXGISharedHandleDescriptor::chain"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryDXGISharedHandleDescriptor,
        chain
    ) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryDXGISharedHandleDescriptor::handle"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryDXGISharedHandleDescriptor,
        handle
    ) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryDXGISharedHandleDescriptor::useKeyedMutex"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryDXGISharedHandleDescriptor,
        useKeyedMutex
    )
        - 24usize];
};
impl Default for WGPUSharedTextureMemoryDXGISharedHandleDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryEGLImageDescriptor {
    pub chain: WGPUChainedStruct,
    pub image: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryEGLImageDescriptor"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryEGLImageDescriptor>() - 24usize];
    ["Alignment of WGPUSharedTextureMemoryEGLImageDescriptor"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryEGLImageDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryEGLImageDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryEGLImageDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryEGLImageDescriptor::image"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryEGLImageDescriptor, image) - 16usize];
};
impl Default for WGPUSharedTextureMemoryEGLImageDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryIOSurfaceDescriptor {
    pub chain: WGPUChainedStruct,
    pub ioSurface: *mut ::core::ffi::c_void,
    pub allowStorageBinding: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryIOSurfaceDescriptor"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryIOSurfaceDescriptor>() - 32usize];
    ["Alignment of WGPUSharedTextureMemoryIOSurfaceDescriptor"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryIOSurfaceDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryIOSurfaceDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryIOSurfaceDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryIOSurfaceDescriptor::ioSurface"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryIOSurfaceDescriptor, ioSurface) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryIOSurfaceDescriptor::allowStorageBinding"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryIOSurfaceDescriptor,
        allowStorageBinding
    )
        - 24usize];
};
impl Default for WGPUSharedTextureMemoryIOSurfaceDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryOpaqueFDDescriptor {
    pub chain: WGPUChainedStruct,
    pub vkImageCreateInfo: *const ::core::ffi::c_void,
    pub memoryFD: ::core::ffi::c_int,
    pub memoryTypeIndex: u32,
    pub allocationSize: u64,
    pub dedicatedAllocation: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryOpaqueFDDescriptor"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryOpaqueFDDescriptor>() - 48usize];
    ["Alignment of WGPUSharedTextureMemoryOpaqueFDDescriptor"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryOpaqueFDDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryOpaqueFDDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryOpaqueFDDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryOpaqueFDDescriptor::vkImageCreateInfo"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryOpaqueFDDescriptor,
        vkImageCreateInfo
    ) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryOpaqueFDDescriptor::memoryFD"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryOpaqueFDDescriptor, memoryFD) - 24usize];
    ["Offset of field: WGPUSharedTextureMemoryOpaqueFDDescriptor::memoryTypeIndex"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryOpaqueFDDescriptor,
        memoryTypeIndex
    ) - 28usize];
    ["Offset of field: WGPUSharedTextureMemoryOpaqueFDDescriptor::allocationSize"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryOpaqueFDDescriptor,
        allocationSize
    ) - 32usize];
    ["Offset of field: WGPUSharedTextureMemoryOpaqueFDDescriptor::dedicatedAllocation"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryOpaqueFDDescriptor,
        dedicatedAllocation
    )
        - 40usize];
};
impl Default for WGPUSharedTextureMemoryOpaqueFDDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor {
    pub chain: WGPUChainedStruct,
    pub dedicatedAllocation: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor"][::core::mem::size_of::<
        WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor,
    >() - 24usize];
    ["Alignment of WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor"][::core::mem::align_of::<
        WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor,
    >() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor::chain"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor,
        chain
    ) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor::dedicatedAllocation"] [:: core :: mem :: offset_of ! (WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor , dedicatedAllocation) - 16usize] ;
};
impl Default for WGPUSharedTextureMemoryVkDedicatedAllocationDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryVkImageLayoutBeginState {
    pub chain: WGPUChainedStruct,
    pub oldLayout: i32,
    pub newLayout: i32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryVkImageLayoutBeginState"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryVkImageLayoutBeginState>() - 24usize];
    ["Alignment of WGPUSharedTextureMemoryVkImageLayoutBeginState"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryVkImageLayoutBeginState>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryVkImageLayoutBeginState::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryVkImageLayoutBeginState, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryVkImageLayoutBeginState::oldLayout"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryVkImageLayoutBeginState,
        oldLayout
    ) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryVkImageLayoutBeginState::newLayout"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryVkImageLayoutBeginState,
        newLayout
    ) - 20usize];
};
impl Default for WGPUSharedTextureMemoryVkImageLayoutBeginState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryVkImageLayoutEndState {
    pub chain: WGPUChainedStruct,
    pub oldLayout: i32,
    pub newLayout: i32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryVkImageLayoutEndState"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryVkImageLayoutEndState>() - 24usize];
    ["Alignment of WGPUSharedTextureMemoryVkImageLayoutEndState"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryVkImageLayoutEndState>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryVkImageLayoutEndState::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryVkImageLayoutEndState, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryVkImageLayoutEndState::oldLayout"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryVkImageLayoutEndState,
        oldLayout
    ) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryVkImageLayoutEndState::newLayout"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryVkImageLayoutEndState,
        newLayout
    ) - 20usize];
};
impl Default for WGPUSharedTextureMemoryVkImageLayoutEndState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryZirconHandleDescriptor {
    pub chain: WGPUChainedStruct,
    pub memoryFD: u32,
    pub allocationSize: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryZirconHandleDescriptor"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryZirconHandleDescriptor>() - 32usize];
    ["Alignment of WGPUSharedTextureMemoryZirconHandleDescriptor"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryZirconHandleDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryZirconHandleDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryZirconHandleDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryZirconHandleDescriptor::memoryFD"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryZirconHandleDescriptor,
        memoryFD
    ) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryZirconHandleDescriptor::allocationSize"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryZirconHandleDescriptor,
        allocationSize
    ) - 24usize];
};
impl Default for WGPUSharedTextureMemoryZirconHandleDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUStaticSamplerBindingLayout {
    pub chain: WGPUChainedStruct,
    pub sampler: WGPUSampler,
    pub sampledTextureBinding: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUStaticSamplerBindingLayout"]
        [::core::mem::size_of::<WGPUStaticSamplerBindingLayout>() - 32usize];
    ["Alignment of WGPUStaticSamplerBindingLayout"]
        [::core::mem::align_of::<WGPUStaticSamplerBindingLayout>() - 8usize];
    ["Offset of field: WGPUStaticSamplerBindingLayout::chain"]
        [::core::mem::offset_of!(WGPUStaticSamplerBindingLayout, chain) - 0usize];
    ["Offset of field: WGPUStaticSamplerBindingLayout::sampler"]
        [::core::mem::offset_of!(WGPUStaticSamplerBindingLayout, sampler) - 16usize];
    ["Offset of field: WGPUStaticSamplerBindingLayout::sampledTextureBinding"]
        [::core::mem::offset_of!(WGPUStaticSamplerBindingLayout, sampledTextureBinding) - 24usize];
};
impl Default for WGPUStaticSamplerBindingLayout {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUStencilFaceState {
    pub compare: WGPUCompareFunction,
    pub failOp: WGPUStencilOperation,
    pub depthFailOp: WGPUStencilOperation,
    pub passOp: WGPUStencilOperation,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUStencilFaceState"][::core::mem::size_of::<WGPUStencilFaceState>() - 16usize];
    ["Alignment of WGPUStencilFaceState"][::core::mem::align_of::<WGPUStencilFaceState>() - 4usize];
    ["Offset of field: WGPUStencilFaceState::compare"]
        [::core::mem::offset_of!(WGPUStencilFaceState, compare) - 0usize];
    ["Offset of field: WGPUStencilFaceState::failOp"]
        [::core::mem::offset_of!(WGPUStencilFaceState, failOp) - 4usize];
    ["Offset of field: WGPUStencilFaceState::depthFailOp"]
        [::core::mem::offset_of!(WGPUStencilFaceState, depthFailOp) - 8usize];
    ["Offset of field: WGPUStencilFaceState::passOp"]
        [::core::mem::offset_of!(WGPUStencilFaceState, passOp) - 12usize];
};
impl Default for WGPUStencilFaceState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUStorageTextureBindingLayout {
    pub nextInChain: *mut WGPUChainedStruct,
    pub access: WGPUStorageTextureAccess,
    pub format: WGPUTextureFormat,
    pub viewDimension: WGPUTextureViewDimension,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUStorageTextureBindingLayout"]
        [::core::mem::size_of::<WGPUStorageTextureBindingLayout>() - 24usize];
    ["Alignment of WGPUStorageTextureBindingLayout"]
        [::core::mem::align_of::<WGPUStorageTextureBindingLayout>() - 8usize];
    ["Offset of field: WGPUStorageTextureBindingLayout::nextInChain"]
        [::core::mem::offset_of!(WGPUStorageTextureBindingLayout, nextInChain) - 0usize];
    ["Offset of field: WGPUStorageTextureBindingLayout::access"]
        [::core::mem::offset_of!(WGPUStorageTextureBindingLayout, access) - 8usize];
    ["Offset of field: WGPUStorageTextureBindingLayout::format"]
        [::core::mem::offset_of!(WGPUStorageTextureBindingLayout, format) - 12usize];
    ["Offset of field: WGPUStorageTextureBindingLayout::viewDimension"]
        [::core::mem::offset_of!(WGPUStorageTextureBindingLayout, viewDimension) - 16usize];
};
impl Default for WGPUStorageTextureBindingLayout {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSubgroupMatrixConfig {
    pub componentType: WGPUSubgroupMatrixComponentType,
    pub resultComponentType: WGPUSubgroupMatrixComponentType,
    pub M: u32,
    pub N: u32,
    pub K: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSubgroupMatrixConfig"]
        [::core::mem::size_of::<WGPUSubgroupMatrixConfig>() - 20usize];
    ["Alignment of WGPUSubgroupMatrixConfig"]
        [::core::mem::align_of::<WGPUSubgroupMatrixConfig>() - 4usize];
    ["Offset of field: WGPUSubgroupMatrixConfig::componentType"]
        [::core::mem::offset_of!(WGPUSubgroupMatrixConfig, componentType) - 0usize];
    ["Offset of field: WGPUSubgroupMatrixConfig::resultComponentType"]
        [::core::mem::offset_of!(WGPUSubgroupMatrixConfig, resultComponentType) - 4usize];
    ["Offset of field: WGPUSubgroupMatrixConfig::M"]
        [::core::mem::offset_of!(WGPUSubgroupMatrixConfig, M) - 8usize];
    ["Offset of field: WGPUSubgroupMatrixConfig::N"]
        [::core::mem::offset_of!(WGPUSubgroupMatrixConfig, N) - 12usize];
    ["Offset of field: WGPUSubgroupMatrixConfig::K"]
        [::core::mem::offset_of!(WGPUSubgroupMatrixConfig, K) - 16usize];
};
impl Default for WGPUSubgroupMatrixConfig {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSupportedFeatures {
    pub featureCount: usize,
    pub features: *const WGPUFeatureName,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSupportedFeatures"][::core::mem::size_of::<WGPUSupportedFeatures>() - 16usize];
    ["Alignment of WGPUSupportedFeatures"]
        [::core::mem::align_of::<WGPUSupportedFeatures>() - 8usize];
    ["Offset of field: WGPUSupportedFeatures::featureCount"]
        [::core::mem::offset_of!(WGPUSupportedFeatures, featureCount) - 0usize];
    ["Offset of field: WGPUSupportedFeatures::features"]
        [::core::mem::offset_of!(WGPUSupportedFeatures, features) - 8usize];
};
impl Default for WGPUSupportedFeatures {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSupportedWGSLLanguageFeatures {
    pub featureCount: usize,
    pub features: *const WGPUWGSLLanguageFeatureName,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSupportedWGSLLanguageFeatures"]
        [::core::mem::size_of::<WGPUSupportedWGSLLanguageFeatures>() - 16usize];
    ["Alignment of WGPUSupportedWGSLLanguageFeatures"]
        [::core::mem::align_of::<WGPUSupportedWGSLLanguageFeatures>() - 8usize];
    ["Offset of field: WGPUSupportedWGSLLanguageFeatures::featureCount"]
        [::core::mem::offset_of!(WGPUSupportedWGSLLanguageFeatures, featureCount) - 0usize];
    ["Offset of field: WGPUSupportedWGSLLanguageFeatures::features"]
        [::core::mem::offset_of!(WGPUSupportedWGSLLanguageFeatures, features) - 8usize];
};
impl Default for WGPUSupportedWGSLLanguageFeatures {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUSurfaceCapabilities {
    pub nextInChain: *mut WGPUChainedStruct,
    pub usages: WGPUTextureUsage,
    pub formatCount: usize,
    pub formats: *const WGPUTextureFormat,
    pub presentModeCount: usize,
    pub presentModes: *const WGPUPresentMode,
    pub alphaModeCount: usize,
    pub alphaModes: *const WGPUCompositeAlphaMode,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceCapabilities"]
        [::core::mem::size_of::<WGPUSurfaceCapabilities>() - 64usize];
    ["Alignment of WGPUSurfaceCapabilities"]
        [::core::mem::align_of::<WGPUSurfaceCapabilities>() - 8usize];
    ["Offset of field: WGPUSurfaceCapabilities::nextInChain"]
        [::core::mem::offset_of!(WGPUSurfaceCapabilities, nextInChain) - 0usize];
    ["Offset of field: WGPUSurfaceCapabilities::usages"]
        [::core::mem::offset_of!(WGPUSurfaceCapabilities, usages) - 8usize];
    ["Offset of field: WGPUSurfaceCapabilities::formatCount"]
        [::core::mem::offset_of!(WGPUSurfaceCapabilities, formatCount) - 16usize];
    ["Offset of field: WGPUSurfaceCapabilities::formats"]
        [::core::mem::offset_of!(WGPUSurfaceCapabilities, formats) - 24usize];
    ["Offset of field: WGPUSurfaceCapabilities::presentModeCount"]
        [::core::mem::offset_of!(WGPUSurfaceCapabilities, presentModeCount) - 32usize];
    ["Offset of field: WGPUSurfaceCapabilities::presentModes"]
        [::core::mem::offset_of!(WGPUSurfaceCapabilities, presentModes) - 40usize];
    ["Offset of field: WGPUSurfaceCapabilities::alphaModeCount"]
        [::core::mem::offset_of!(WGPUSurfaceCapabilities, alphaModeCount) - 48usize];
    ["Offset of field: WGPUSurfaceCapabilities::alphaModes"]
        [::core::mem::offset_of!(WGPUSurfaceCapabilities, alphaModes) - 56usize];
};
impl Default for WGPUSurfaceCapabilities {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceColorManagement {
    pub chain: WGPUChainedStruct,
    pub colorSpace: WGPUPredefinedColorSpace,
    pub toneMappingMode: WGPUToneMappingMode,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceColorManagement"]
        [::core::mem::size_of::<WGPUSurfaceColorManagement>() - 24usize];
    ["Alignment of WGPUSurfaceColorManagement"]
        [::core::mem::align_of::<WGPUSurfaceColorManagement>() - 8usize];
    ["Offset of field: WGPUSurfaceColorManagement::chain"]
        [::core::mem::offset_of!(WGPUSurfaceColorManagement, chain) - 0usize];
    ["Offset of field: WGPUSurfaceColorManagement::colorSpace"]
        [::core::mem::offset_of!(WGPUSurfaceColorManagement, colorSpace) - 16usize];
    ["Offset of field: WGPUSurfaceColorManagement::toneMappingMode"]
        [::core::mem::offset_of!(WGPUSurfaceColorManagement, toneMappingMode) - 20usize];
};
impl Default for WGPUSurfaceColorManagement {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUSurfaceConfiguration {
    pub nextInChain: *mut WGPUChainedStruct,
    pub device: WGPUDevice,
    pub format: WGPUTextureFormat,
    pub usage: WGPUTextureUsage,
    pub width: u32,
    pub height: u32,
    pub viewFormatCount: usize,
    pub viewFormats: *const WGPUTextureFormat,
    pub alphaMode: WGPUCompositeAlphaMode,
    pub presentMode: WGPUPresentMode,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceConfiguration"]
        [::core::mem::size_of::<WGPUSurfaceConfiguration>() - 64usize];
    ["Alignment of WGPUSurfaceConfiguration"]
        [::core::mem::align_of::<WGPUSurfaceConfiguration>() - 8usize];
    ["Offset of field: WGPUSurfaceConfiguration::nextInChain"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, nextInChain) - 0usize];
    ["Offset of field: WGPUSurfaceConfiguration::device"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, device) - 8usize];
    ["Offset of field: WGPUSurfaceConfiguration::format"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, format) - 16usize];
    ["Offset of field: WGPUSurfaceConfiguration::usage"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, usage) - 24usize];
    ["Offset of field: WGPUSurfaceConfiguration::width"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, width) - 32usize];
    ["Offset of field: WGPUSurfaceConfiguration::height"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, height) - 36usize];
    ["Offset of field: WGPUSurfaceConfiguration::viewFormatCount"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, viewFormatCount) - 40usize];
    ["Offset of field: WGPUSurfaceConfiguration::viewFormats"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, viewFormats) - 48usize];
    ["Offset of field: WGPUSurfaceConfiguration::alphaMode"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, alphaMode) - 56usize];
    ["Offset of field: WGPUSurfaceConfiguration::presentMode"]
        [::core::mem::offset_of!(WGPUSurfaceConfiguration, presentMode) - 60usize];
};
impl Default for WGPUSurfaceConfiguration {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceDescriptorFromWindowsCoreWindow {
    pub chain: WGPUChainedStruct,
    pub coreWindow: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceDescriptorFromWindowsCoreWindow"]
        [::core::mem::size_of::<WGPUSurfaceDescriptorFromWindowsCoreWindow>() - 24usize];
    ["Alignment of WGPUSurfaceDescriptorFromWindowsCoreWindow"]
        [::core::mem::align_of::<WGPUSurfaceDescriptorFromWindowsCoreWindow>() - 8usize];
    ["Offset of field: WGPUSurfaceDescriptorFromWindowsCoreWindow::chain"]
        [::core::mem::offset_of!(WGPUSurfaceDescriptorFromWindowsCoreWindow, chain) - 0usize];
    ["Offset of field: WGPUSurfaceDescriptorFromWindowsCoreWindow::coreWindow"]
        [::core::mem::offset_of!(WGPUSurfaceDescriptorFromWindowsCoreWindow, coreWindow) - 16usize];
};
impl Default for WGPUSurfaceDescriptorFromWindowsCoreWindow {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel {
    pub chain: WGPUChainedStruct,
    pub swapChainPanel: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel"]
        [::core::mem::size_of::<WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel>() - 24usize];
    ["Alignment of WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel"]
        [::core::mem::align_of::<WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel>() - 8usize];
    ["Offset of field: WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel::chain"][::core::mem::offset_of!(
        WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel,
        chain
    ) - 0usize];
    ["Offset of field: WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel::swapChainPanel"][::core::mem::offset_of!(
        WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel,
        swapChainPanel
    )
        - 16usize];
};
impl Default for WGPUSurfaceDescriptorFromWindowsUWPSwapChainPanel {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel {
    pub chain: WGPUChainedStruct,
    pub swapChainPanel: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel"]
        [::core::mem::size_of::<WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel>() - 24usize];
    ["Alignment of WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel"]
        [::core::mem::align_of::<WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel>() - 8usize];
    ["Offset of field: WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel::chain"][::core::mem::offset_of!(
        WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel,
        chain
    ) - 0usize];
    ["Offset of field: WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel::swapChainPanel"][::core::mem::offset_of!(
        WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel,
        swapChainPanel
    )
        - 16usize];
};
impl Default for WGPUSurfaceDescriptorFromWindowsWinUISwapChainPanel {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceSourceAndroidNativeWindow {
    pub chain: WGPUChainedStruct,
    pub window: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceSourceAndroidNativeWindow"]
        [::core::mem::size_of::<WGPUSurfaceSourceAndroidNativeWindow>() - 24usize];
    ["Alignment of WGPUSurfaceSourceAndroidNativeWindow"]
        [::core::mem::align_of::<WGPUSurfaceSourceAndroidNativeWindow>() - 8usize];
    ["Offset of field: WGPUSurfaceSourceAndroidNativeWindow::chain"]
        [::core::mem::offset_of!(WGPUSurfaceSourceAndroidNativeWindow, chain) - 0usize];
    ["Offset of field: WGPUSurfaceSourceAndroidNativeWindow::window"]
        [::core::mem::offset_of!(WGPUSurfaceSourceAndroidNativeWindow, window) - 16usize];
};
impl Default for WGPUSurfaceSourceAndroidNativeWindow {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceSourceMetalLayer {
    pub chain: WGPUChainedStruct,
    pub layer: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceSourceMetalLayer"]
        [::core::mem::size_of::<WGPUSurfaceSourceMetalLayer>() - 24usize];
    ["Alignment of WGPUSurfaceSourceMetalLayer"]
        [::core::mem::align_of::<WGPUSurfaceSourceMetalLayer>() - 8usize];
    ["Offset of field: WGPUSurfaceSourceMetalLayer::chain"]
        [::core::mem::offset_of!(WGPUSurfaceSourceMetalLayer, chain) - 0usize];
    ["Offset of field: WGPUSurfaceSourceMetalLayer::layer"]
        [::core::mem::offset_of!(WGPUSurfaceSourceMetalLayer, layer) - 16usize];
};
impl Default for WGPUSurfaceSourceMetalLayer {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceSourceWaylandSurface {
    pub chain: WGPUChainedStruct,
    pub display: *mut ::core::ffi::c_void,
    pub surface: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceSourceWaylandSurface"]
        [::core::mem::size_of::<WGPUSurfaceSourceWaylandSurface>() - 32usize];
    ["Alignment of WGPUSurfaceSourceWaylandSurface"]
        [::core::mem::align_of::<WGPUSurfaceSourceWaylandSurface>() - 8usize];
    ["Offset of field: WGPUSurfaceSourceWaylandSurface::chain"]
        [::core::mem::offset_of!(WGPUSurfaceSourceWaylandSurface, chain) - 0usize];
    ["Offset of field: WGPUSurfaceSourceWaylandSurface::display"]
        [::core::mem::offset_of!(WGPUSurfaceSourceWaylandSurface, display) - 16usize];
    ["Offset of field: WGPUSurfaceSourceWaylandSurface::surface"]
        [::core::mem::offset_of!(WGPUSurfaceSourceWaylandSurface, surface) - 24usize];
};
impl Default for WGPUSurfaceSourceWaylandSurface {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceSourceWindowsHWND {
    pub chain: WGPUChainedStruct,
    pub hinstance: *mut ::core::ffi::c_void,
    pub hwnd: *mut ::core::ffi::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceSourceWindowsHWND"]
        [::core::mem::size_of::<WGPUSurfaceSourceWindowsHWND>() - 32usize];
    ["Alignment of WGPUSurfaceSourceWindowsHWND"]
        [::core::mem::align_of::<WGPUSurfaceSourceWindowsHWND>() - 8usize];
    ["Offset of field: WGPUSurfaceSourceWindowsHWND::chain"]
        [::core::mem::offset_of!(WGPUSurfaceSourceWindowsHWND, chain) - 0usize];
    ["Offset of field: WGPUSurfaceSourceWindowsHWND::hinstance"]
        [::core::mem::offset_of!(WGPUSurfaceSourceWindowsHWND, hinstance) - 16usize];
    ["Offset of field: WGPUSurfaceSourceWindowsHWND::hwnd"]
        [::core::mem::offset_of!(WGPUSurfaceSourceWindowsHWND, hwnd) - 24usize];
};
impl Default for WGPUSurfaceSourceWindowsHWND {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceSourceXCBWindow {
    pub chain: WGPUChainedStruct,
    pub connection: *mut ::core::ffi::c_void,
    pub window: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceSourceXCBWindow"]
        [::core::mem::size_of::<WGPUSurfaceSourceXCBWindow>() - 32usize];
    ["Alignment of WGPUSurfaceSourceXCBWindow"]
        [::core::mem::align_of::<WGPUSurfaceSourceXCBWindow>() - 8usize];
    ["Offset of field: WGPUSurfaceSourceXCBWindow::chain"]
        [::core::mem::offset_of!(WGPUSurfaceSourceXCBWindow, chain) - 0usize];
    ["Offset of field: WGPUSurfaceSourceXCBWindow::connection"]
        [::core::mem::offset_of!(WGPUSurfaceSourceXCBWindow, connection) - 16usize];
    ["Offset of field: WGPUSurfaceSourceXCBWindow::window"]
        [::core::mem::offset_of!(WGPUSurfaceSourceXCBWindow, window) - 24usize];
};
impl Default for WGPUSurfaceSourceXCBWindow {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceSourceXlibWindow {
    pub chain: WGPUChainedStruct,
    pub display: *mut ::core::ffi::c_void,
    pub window: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceSourceXlibWindow"]
        [::core::mem::size_of::<WGPUSurfaceSourceXlibWindow>() - 32usize];
    ["Alignment of WGPUSurfaceSourceXlibWindow"]
        [::core::mem::align_of::<WGPUSurfaceSourceXlibWindow>() - 8usize];
    ["Offset of field: WGPUSurfaceSourceXlibWindow::chain"]
        [::core::mem::offset_of!(WGPUSurfaceSourceXlibWindow, chain) - 0usize];
    ["Offset of field: WGPUSurfaceSourceXlibWindow::display"]
        [::core::mem::offset_of!(WGPUSurfaceSourceXlibWindow, display) - 16usize];
    ["Offset of field: WGPUSurfaceSourceXlibWindow::window"]
        [::core::mem::offset_of!(WGPUSurfaceSourceXlibWindow, window) - 24usize];
};
impl Default for WGPUSurfaceSourceXlibWindow {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceTexture {
    pub nextInChain: *mut WGPUChainedStruct,
    pub texture: WGPUTexture,
    pub status: WGPUSurfaceGetCurrentTextureStatus,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceTexture"][::core::mem::size_of::<WGPUSurfaceTexture>() - 24usize];
    ["Alignment of WGPUSurfaceTexture"][::core::mem::align_of::<WGPUSurfaceTexture>() - 8usize];
    ["Offset of field: WGPUSurfaceTexture::nextInChain"]
        [::core::mem::offset_of!(WGPUSurfaceTexture, nextInChain) - 0usize];
    ["Offset of field: WGPUSurfaceTexture::texture"]
        [::core::mem::offset_of!(WGPUSurfaceTexture, texture) - 8usize];
    ["Offset of field: WGPUSurfaceTexture::status"]
        [::core::mem::offset_of!(WGPUSurfaceTexture, status) - 16usize];
};
impl Default for WGPUSurfaceTexture {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTexelCopyBufferLayout {
    pub offset: u64,
    pub bytesPerRow: u32,
    pub rowsPerImage: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUTexelCopyBufferLayout"]
        [::core::mem::size_of::<WGPUTexelCopyBufferLayout>() - 16usize];
    ["Alignment of WGPUTexelCopyBufferLayout"]
        [::core::mem::align_of::<WGPUTexelCopyBufferLayout>() - 8usize];
    ["Offset of field: WGPUTexelCopyBufferLayout::offset"]
        [::core::mem::offset_of!(WGPUTexelCopyBufferLayout, offset) - 0usize];
    ["Offset of field: WGPUTexelCopyBufferLayout::bytesPerRow"]
        [::core::mem::offset_of!(WGPUTexelCopyBufferLayout, bytesPerRow) - 8usize];
    ["Offset of field: WGPUTexelCopyBufferLayout::rowsPerImage"]
        [::core::mem::offset_of!(WGPUTexelCopyBufferLayout, rowsPerImage) - 12usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTextureBindingLayout {
    pub nextInChain: *mut WGPUChainedStruct,
    pub sampleType: WGPUTextureSampleType,
    pub viewDimension: WGPUTextureViewDimension,
    pub multisampled: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUTextureBindingLayout"]
        [::core::mem::size_of::<WGPUTextureBindingLayout>() - 24usize];
    ["Alignment of WGPUTextureBindingLayout"]
        [::core::mem::align_of::<WGPUTextureBindingLayout>() - 8usize];
    ["Offset of field: WGPUTextureBindingLayout::nextInChain"]
        [::core::mem::offset_of!(WGPUTextureBindingLayout, nextInChain) - 0usize];
    ["Offset of field: WGPUTextureBindingLayout::sampleType"]
        [::core::mem::offset_of!(WGPUTextureBindingLayout, sampleType) - 8usize];
    ["Offset of field: WGPUTextureBindingLayout::viewDimension"]
        [::core::mem::offset_of!(WGPUTextureBindingLayout, viewDimension) - 12usize];
    ["Offset of field: WGPUTextureBindingLayout::multisampled"]
        [::core::mem::offset_of!(WGPUTextureBindingLayout, multisampled) - 16usize];
};
impl Default for WGPUTextureBindingLayout {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTextureBindingViewDimensionDescriptor {
    pub chain: WGPUChainedStruct,
    pub textureBindingViewDimension: WGPUTextureViewDimension,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUTextureBindingViewDimensionDescriptor"]
        [::core::mem::size_of::<WGPUTextureBindingViewDimensionDescriptor>() - 24usize];
    ["Alignment of WGPUTextureBindingViewDimensionDescriptor"]
        [::core::mem::align_of::<WGPUTextureBindingViewDimensionDescriptor>() - 8usize];
    ["Offset of field: WGPUTextureBindingViewDimensionDescriptor::chain"]
        [::core::mem::offset_of!(WGPUTextureBindingViewDimensionDescriptor, chain) - 0usize];
    ["Offset of field: WGPUTextureBindingViewDimensionDescriptor::textureBindingViewDimension"][::core::mem::offset_of!(
        WGPUTextureBindingViewDimensionDescriptor,
        textureBindingViewDimension
    )
        - 16usize];
};
impl Default for WGPUTextureBindingViewDimensionDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUVertexAttribute {
    pub nextInChain: *mut WGPUChainedStruct,
    pub format: WGPUVertexFormat,
    pub offset: u64,
    pub shaderLocation: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUVertexAttribute"][::core::mem::size_of::<WGPUVertexAttribute>() - 32usize];
    ["Alignment of WGPUVertexAttribute"][::core::mem::align_of::<WGPUVertexAttribute>() - 8usize];
    ["Offset of field: WGPUVertexAttribute::nextInChain"]
        [::core::mem::offset_of!(WGPUVertexAttribute, nextInChain) - 0usize];
    ["Offset of field: WGPUVertexAttribute::format"]
        [::core::mem::offset_of!(WGPUVertexAttribute, format) - 8usize];
    ["Offset of field: WGPUVertexAttribute::offset"]
        [::core::mem::offset_of!(WGPUVertexAttribute, offset) - 16usize];
    ["Offset of field: WGPUVertexAttribute::shaderLocation"]
        [::core::mem::offset_of!(WGPUVertexAttribute, shaderLocation) - 24usize];
};
impl Default for WGPUVertexAttribute {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUYCbCrVkDescriptor {
    pub chain: WGPUChainedStruct,
    pub vkFormat: u32,
    pub vkYCbCrModel: u32,
    pub vkYCbCrRange: u32,
    pub vkComponentSwizzleRed: u32,
    pub vkComponentSwizzleGreen: u32,
    pub vkComponentSwizzleBlue: u32,
    pub vkComponentSwizzleAlpha: u32,
    pub vkXChromaOffset: u32,
    pub vkYChromaOffset: u32,
    pub vkChromaFilter: WGPUFilterMode,
    pub forceExplicitReconstruction: WGPUBool,
    pub externalFormat: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUYCbCrVkDescriptor"][::core::mem::size_of::<WGPUYCbCrVkDescriptor>() - 72usize];
    ["Alignment of WGPUYCbCrVkDescriptor"]
        [::core::mem::align_of::<WGPUYCbCrVkDescriptor>() - 8usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::chain"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, chain) - 0usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkFormat"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkFormat) - 16usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkYCbCrModel"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkYCbCrModel) - 20usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkYCbCrRange"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkYCbCrRange) - 24usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkComponentSwizzleRed"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkComponentSwizzleRed) - 28usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkComponentSwizzleGreen"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkComponentSwizzleGreen) - 32usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkComponentSwizzleBlue"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkComponentSwizzleBlue) - 36usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkComponentSwizzleAlpha"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkComponentSwizzleAlpha) - 40usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkXChromaOffset"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkXChromaOffset) - 44usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkYChromaOffset"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkYChromaOffset) - 48usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::vkChromaFilter"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, vkChromaFilter) - 52usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::forceExplicitReconstruction"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, forceExplicitReconstruction) - 56usize];
    ["Offset of field: WGPUYCbCrVkDescriptor::externalFormat"]
        [::core::mem::offset_of!(WGPUYCbCrVkDescriptor, externalFormat) - 64usize];
};
impl Default for WGPUYCbCrVkDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAdapterPropertiesMemoryHeaps {
    pub chain: WGPUChainedStruct,
    pub heapCount: usize,
    pub heapInfo: *const WGPUMemoryHeapInfo,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUAdapterPropertiesMemoryHeaps"]
        [::core::mem::size_of::<WGPUAdapterPropertiesMemoryHeaps>() - 32usize];
    ["Alignment of WGPUAdapterPropertiesMemoryHeaps"]
        [::core::mem::align_of::<WGPUAdapterPropertiesMemoryHeaps>() - 8usize];
    ["Offset of field: WGPUAdapterPropertiesMemoryHeaps::chain"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesMemoryHeaps, chain) - 0usize];
    ["Offset of field: WGPUAdapterPropertiesMemoryHeaps::heapCount"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesMemoryHeaps, heapCount) - 16usize];
    ["Offset of field: WGPUAdapterPropertiesMemoryHeaps::heapInfo"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesMemoryHeaps, heapInfo) - 24usize];
};
impl Default for WGPUAdapterPropertiesMemoryHeaps {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAdapterPropertiesSubgroupMatrixConfigs {
    pub chain: WGPUChainedStruct,
    pub configCount: usize,
    pub configs: *const WGPUSubgroupMatrixConfig,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUAdapterPropertiesSubgroupMatrixConfigs"]
        [::core::mem::size_of::<WGPUAdapterPropertiesSubgroupMatrixConfigs>() - 32usize];
    ["Alignment of WGPUAdapterPropertiesSubgroupMatrixConfigs"]
        [::core::mem::align_of::<WGPUAdapterPropertiesSubgroupMatrixConfigs>() - 8usize];
    ["Offset of field: WGPUAdapterPropertiesSubgroupMatrixConfigs::chain"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesSubgroupMatrixConfigs, chain) - 0usize];
    ["Offset of field: WGPUAdapterPropertiesSubgroupMatrixConfigs::configCount"][::core::mem::offset_of!(
        WGPUAdapterPropertiesSubgroupMatrixConfigs,
        configCount
    ) - 16usize];
    ["Offset of field: WGPUAdapterPropertiesSubgroupMatrixConfigs::configs"]
        [::core::mem::offset_of!(WGPUAdapterPropertiesSubgroupMatrixConfigs, configs) - 24usize];
};
impl Default for WGPUAdapterPropertiesSubgroupMatrixConfigs {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAHardwareBufferProperties {
    pub yCbCrInfo: WGPUYCbCrVkDescriptor,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUAHardwareBufferProperties"]
        [::core::mem::size_of::<WGPUAHardwareBufferProperties>() - 72usize];
    ["Alignment of WGPUAHardwareBufferProperties"]
        [::core::mem::align_of::<WGPUAHardwareBufferProperties>() - 8usize];
    ["Offset of field: WGPUAHardwareBufferProperties::yCbCrInfo"]
        [::core::mem::offset_of!(WGPUAHardwareBufferProperties, yCbCrInfo) - 0usize];
};
impl Default for WGPUAHardwareBufferProperties {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBindGroupEntry {
    pub nextInChain: *mut WGPUChainedStruct,
    pub binding: u32,
    pub buffer: WGPUBuffer,
    pub offset: u64,
    pub size: u64,
    pub sampler: WGPUSampler,
    pub textureView: WGPUTextureView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBindGroupEntry"][::core::mem::size_of::<WGPUBindGroupEntry>() - 56usize];
    ["Alignment of WGPUBindGroupEntry"][::core::mem::align_of::<WGPUBindGroupEntry>() - 8usize];
    ["Offset of field: WGPUBindGroupEntry::nextInChain"]
        [::core::mem::offset_of!(WGPUBindGroupEntry, nextInChain) - 0usize];
    ["Offset of field: WGPUBindGroupEntry::binding"]
        [::core::mem::offset_of!(WGPUBindGroupEntry, binding) - 8usize];
    ["Offset of field: WGPUBindGroupEntry::buffer"]
        [::core::mem::offset_of!(WGPUBindGroupEntry, buffer) - 16usize];
    ["Offset of field: WGPUBindGroupEntry::offset"]
        [::core::mem::offset_of!(WGPUBindGroupEntry, offset) - 24usize];
    ["Offset of field: WGPUBindGroupEntry::size"]
        [::core::mem::offset_of!(WGPUBindGroupEntry, size) - 32usize];
    ["Offset of field: WGPUBindGroupEntry::sampler"]
        [::core::mem::offset_of!(WGPUBindGroupEntry, sampler) - 40usize];
    ["Offset of field: WGPUBindGroupEntry::textureView"]
        [::core::mem::offset_of!(WGPUBindGroupEntry, textureView) - 48usize];
};
impl Default for WGPUBindGroupEntry {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUBindGroupLayoutEntry {
    pub nextInChain: *mut WGPUChainedStruct,
    pub binding: u32,
    pub visibility: WGPUShaderStage,
    pub buffer: WGPUBufferBindingLayout,
    pub sampler: WGPUSamplerBindingLayout,
    pub texture: WGPUTextureBindingLayout,
    pub storageTexture: WGPUStorageTextureBindingLayout,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBindGroupLayoutEntry"]
        [::core::mem::size_of::<WGPUBindGroupLayoutEntry>() - 112usize];
    ["Alignment of WGPUBindGroupLayoutEntry"]
        [::core::mem::align_of::<WGPUBindGroupLayoutEntry>() - 8usize];
    ["Offset of field: WGPUBindGroupLayoutEntry::nextInChain"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutEntry, nextInChain) - 0usize];
    ["Offset of field: WGPUBindGroupLayoutEntry::binding"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutEntry, binding) - 8usize];
    ["Offset of field: WGPUBindGroupLayoutEntry::visibility"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutEntry, visibility) - 16usize];
    ["Offset of field: WGPUBindGroupLayoutEntry::buffer"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutEntry, buffer) - 24usize];
    ["Offset of field: WGPUBindGroupLayoutEntry::sampler"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutEntry, sampler) - 48usize];
    ["Offset of field: WGPUBindGroupLayoutEntry::texture"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutEntry, texture) - 64usize];
    ["Offset of field: WGPUBindGroupLayoutEntry::storageTexture"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutEntry, storageTexture) - 88usize];
};
impl Default for WGPUBindGroupLayoutEntry {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBlendState {
    pub color: WGPUBlendComponent,
    pub alpha: WGPUBlendComponent,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBlendState"][::core::mem::size_of::<WGPUBlendState>() - 24usize];
    ["Alignment of WGPUBlendState"][::core::mem::align_of::<WGPUBlendState>() - 4usize];
    ["Offset of field: WGPUBlendState::color"]
        [::core::mem::offset_of!(WGPUBlendState, color) - 0usize];
    ["Offset of field: WGPUBlendState::alpha"]
        [::core::mem::offset_of!(WGPUBlendState, alpha) - 12usize];
};
impl Default for WGPUBlendState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUBufferDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub usage: WGPUBufferUsage,
    pub size: u64,
    pub mappedAtCreation: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBufferDescriptor"][::core::mem::size_of::<WGPUBufferDescriptor>() - 48usize];
    ["Alignment of WGPUBufferDescriptor"][::core::mem::align_of::<WGPUBufferDescriptor>() - 8usize];
    ["Offset of field: WGPUBufferDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUBufferDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUBufferDescriptor::label"]
        [::core::mem::offset_of!(WGPUBufferDescriptor, label) - 8usize];
    ["Offset of field: WGPUBufferDescriptor::usage"]
        [::core::mem::offset_of!(WGPUBufferDescriptor, usage) - 24usize];
    ["Offset of field: WGPUBufferDescriptor::size"]
        [::core::mem::offset_of!(WGPUBufferDescriptor, size) - 32usize];
    ["Offset of field: WGPUBufferDescriptor::mappedAtCreation"]
        [::core::mem::offset_of!(WGPUBufferDescriptor, mappedAtCreation) - 40usize];
};
impl Default for WGPUBufferDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCommandEncoderDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUCommandEncoderDescriptor"]
        [::core::mem::size_of::<WGPUCommandEncoderDescriptor>() - 24usize];
    ["Alignment of WGPUCommandEncoderDescriptor"]
        [::core::mem::align_of::<WGPUCommandEncoderDescriptor>() - 8usize];
    ["Offset of field: WGPUCommandEncoderDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUCommandEncoderDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUCommandEncoderDescriptor::label"]
        [::core::mem::offset_of!(WGPUCommandEncoderDescriptor, label) - 8usize];
};
impl Default for WGPUCommandEncoderDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCompilationMessage {
    pub nextInChain: *mut WGPUChainedStruct,
    pub message: WGPUStringView,
    pub type_: WGPUCompilationMessageType,
    pub lineNum: u64,
    pub linePos: u64,
    pub offset: u64,
    pub length: u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUCompilationMessage"][::core::mem::size_of::<WGPUCompilationMessage>() - 64usize];
    ["Alignment of WGPUCompilationMessage"]
        [::core::mem::align_of::<WGPUCompilationMessage>() - 8usize];
    ["Offset of field: WGPUCompilationMessage::nextInChain"]
        [::core::mem::offset_of!(WGPUCompilationMessage, nextInChain) - 0usize];
    ["Offset of field: WGPUCompilationMessage::message"]
        [::core::mem::offset_of!(WGPUCompilationMessage, message) - 8usize];
    ["Offset of field: WGPUCompilationMessage::type_"]
        [::core::mem::offset_of!(WGPUCompilationMessage, type_) - 24usize];
    ["Offset of field: WGPUCompilationMessage::lineNum"]
        [::core::mem::offset_of!(WGPUCompilationMessage, lineNum) - 32usize];
    ["Offset of field: WGPUCompilationMessage::linePos"]
        [::core::mem::offset_of!(WGPUCompilationMessage, linePos) - 40usize];
    ["Offset of field: WGPUCompilationMessage::offset"]
        [::core::mem::offset_of!(WGPUCompilationMessage, offset) - 48usize];
    ["Offset of field: WGPUCompilationMessage::length"]
        [::core::mem::offset_of!(WGPUCompilationMessage, length) - 56usize];
};
impl Default for WGPUCompilationMessage {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUComputePassDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub timestampWrites: *const WGPUPassTimestampWrites,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUComputePassDescriptor"]
        [::core::mem::size_of::<WGPUComputePassDescriptor>() - 32usize];
    ["Alignment of WGPUComputePassDescriptor"]
        [::core::mem::align_of::<WGPUComputePassDescriptor>() - 8usize];
    ["Offset of field: WGPUComputePassDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUComputePassDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUComputePassDescriptor::label"]
        [::core::mem::offset_of!(WGPUComputePassDescriptor, label) - 8usize];
    ["Offset of field: WGPUComputePassDescriptor::timestampWrites"]
        [::core::mem::offset_of!(WGPUComputePassDescriptor, timestampWrites) - 24usize];
};
impl Default for WGPUComputePassDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUComputeState {
    pub nextInChain: *mut WGPUChainedStruct,
    pub module: WGPUShaderModule,
    pub entryPoint: WGPUStringView,
    pub constantCount: usize,
    pub constants: *const WGPUConstantEntry,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUComputeState"][::core::mem::size_of::<WGPUComputeState>() - 48usize];
    ["Alignment of WGPUComputeState"][::core::mem::align_of::<WGPUComputeState>() - 8usize];
    ["Offset of field: WGPUComputeState::nextInChain"]
        [::core::mem::offset_of!(WGPUComputeState, nextInChain) - 0usize];
    ["Offset of field: WGPUComputeState::module"]
        [::core::mem::offset_of!(WGPUComputeState, module) - 8usize];
    ["Offset of field: WGPUComputeState::entryPoint"]
        [::core::mem::offset_of!(WGPUComputeState, entryPoint) - 16usize];
    ["Offset of field: WGPUComputeState::constantCount"]
        [::core::mem::offset_of!(WGPUComputeState, constantCount) - 32usize];
    ["Offset of field: WGPUComputeState::constants"]
        [::core::mem::offset_of!(WGPUComputeState, constants) - 40usize];
};
impl Default for WGPUComputeState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnDrmFormatCapabilities {
    pub chain: WGPUChainedStruct,
    pub propertiesCount: usize,
    pub properties: *const WGPUDawnDrmFormatProperties,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnDrmFormatCapabilities"]
        [::core::mem::size_of::<WGPUDawnDrmFormatCapabilities>() - 32usize];
    ["Alignment of WGPUDawnDrmFormatCapabilities"]
        [::core::mem::align_of::<WGPUDawnDrmFormatCapabilities>() - 8usize];
    ["Offset of field: WGPUDawnDrmFormatCapabilities::chain"]
        [::core::mem::offset_of!(WGPUDawnDrmFormatCapabilities, chain) - 0usize];
    ["Offset of field: WGPUDawnDrmFormatCapabilities::propertiesCount"]
        [::core::mem::offset_of!(WGPUDawnDrmFormatCapabilities, propertiesCount) - 16usize];
    ["Offset of field: WGPUDawnDrmFormatCapabilities::properties"]
        [::core::mem::offset_of!(WGPUDawnDrmFormatCapabilities, properties) - 24usize];
};
impl Default for WGPUDawnDrmFormatCapabilities {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct WGPUDepthStencilState {
    pub nextInChain: *mut WGPUChainedStruct,
    pub format: WGPUTextureFormat,
    pub depthWriteEnabled: WGPUOptionalBool,
    pub depthCompare: WGPUCompareFunction,
    pub stencilFront: WGPUStencilFaceState,
    pub stencilBack: WGPUStencilFaceState,
    pub stencilReadMask: u32,
    pub stencilWriteMask: u32,
    pub depthBias: i32,
    pub depthBiasSlopeScale: f32,
    pub depthBiasClamp: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDepthStencilState"][::core::mem::size_of::<WGPUDepthStencilState>() - 72usize];
    ["Alignment of WGPUDepthStencilState"]
        [::core::mem::align_of::<WGPUDepthStencilState>() - 8usize];
    ["Offset of field: WGPUDepthStencilState::nextInChain"]
        [::core::mem::offset_of!(WGPUDepthStencilState, nextInChain) - 0usize];
    ["Offset of field: WGPUDepthStencilState::format"]
        [::core::mem::offset_of!(WGPUDepthStencilState, format) - 8usize];
    ["Offset of field: WGPUDepthStencilState::depthWriteEnabled"]
        [::core::mem::offset_of!(WGPUDepthStencilState, depthWriteEnabled) - 12usize];
    ["Offset of field: WGPUDepthStencilState::depthCompare"]
        [::core::mem::offset_of!(WGPUDepthStencilState, depthCompare) - 16usize];
    ["Offset of field: WGPUDepthStencilState::stencilFront"]
        [::core::mem::offset_of!(WGPUDepthStencilState, stencilFront) - 20usize];
    ["Offset of field: WGPUDepthStencilState::stencilBack"]
        [::core::mem::offset_of!(WGPUDepthStencilState, stencilBack) - 36usize];
    ["Offset of field: WGPUDepthStencilState::stencilReadMask"]
        [::core::mem::offset_of!(WGPUDepthStencilState, stencilReadMask) - 52usize];
    ["Offset of field: WGPUDepthStencilState::stencilWriteMask"]
        [::core::mem::offset_of!(WGPUDepthStencilState, stencilWriteMask) - 56usize];
    ["Offset of field: WGPUDepthStencilState::depthBias"]
        [::core::mem::offset_of!(WGPUDepthStencilState, depthBias) - 60usize];
    ["Offset of field: WGPUDepthStencilState::depthBiasSlopeScale"]
        [::core::mem::offset_of!(WGPUDepthStencilState, depthBiasSlopeScale) - 64usize];
    ["Offset of field: WGPUDepthStencilState::depthBiasClamp"]
        [::core::mem::offset_of!(WGPUDepthStencilState, depthBiasClamp) - 68usize];
};
impl Default for WGPUDepthStencilState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUExternalTextureDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub plane0: WGPUTextureView,
    pub plane1: WGPUTextureView,
    pub cropOrigin: WGPUOrigin2D,
    pub cropSize: WGPUExtent2D,
    pub apparentSize: WGPUExtent2D,
    pub doYuvToRgbConversionOnly: WGPUBool,
    pub yuvToRgbConversionMatrix: *const f32,
    pub srcTransferFunctionParameters: *const f32,
    pub dstTransferFunctionParameters: *const f32,
    pub gamutConversionMatrix: *const f32,
    pub mirrored: WGPUBool,
    pub rotation: WGPUExternalTextureRotation,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUExternalTextureDescriptor"]
        [::core::mem::size_of::<WGPUExternalTextureDescriptor>() - 112usize];
    ["Alignment of WGPUExternalTextureDescriptor"]
        [::core::mem::align_of::<WGPUExternalTextureDescriptor>() - 8usize];
    ["Offset of field: WGPUExternalTextureDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUExternalTextureDescriptor::label"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, label) - 8usize];
    ["Offset of field: WGPUExternalTextureDescriptor::plane0"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, plane0) - 24usize];
    ["Offset of field: WGPUExternalTextureDescriptor::plane1"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, plane1) - 32usize];
    ["Offset of field: WGPUExternalTextureDescriptor::cropOrigin"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, cropOrigin) - 40usize];
    ["Offset of field: WGPUExternalTextureDescriptor::cropSize"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, cropSize) - 48usize];
    ["Offset of field: WGPUExternalTextureDescriptor::apparentSize"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, apparentSize) - 56usize];
    ["Offset of field: WGPUExternalTextureDescriptor::doYuvToRgbConversionOnly"][::core::mem::offset_of!(
        WGPUExternalTextureDescriptor,
        doYuvToRgbConversionOnly
    ) - 64usize];
    ["Offset of field: WGPUExternalTextureDescriptor::yuvToRgbConversionMatrix"][::core::mem::offset_of!(
        WGPUExternalTextureDescriptor,
        yuvToRgbConversionMatrix
    ) - 72usize];
    ["Offset of field: WGPUExternalTextureDescriptor::srcTransferFunctionParameters"][::core::mem::offset_of!(
        WGPUExternalTextureDescriptor,
        srcTransferFunctionParameters
    ) - 80usize];
    ["Offset of field: WGPUExternalTextureDescriptor::dstTransferFunctionParameters"][::core::mem::offset_of!(
        WGPUExternalTextureDescriptor,
        dstTransferFunctionParameters
    ) - 88usize];
    ["Offset of field: WGPUExternalTextureDescriptor::gamutConversionMatrix"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, gamutConversionMatrix) - 96usize];
    ["Offset of field: WGPUExternalTextureDescriptor::mirrored"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, mirrored) - 104usize];
    ["Offset of field: WGPUExternalTextureDescriptor::rotation"]
        [::core::mem::offset_of!(WGPUExternalTextureDescriptor, rotation) - 108usize];
};
impl Default for WGPUExternalTextureDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUFutureWaitInfo {
    pub future: WGPUFuture,
    pub completed: WGPUBool,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUFutureWaitInfo"][::core::mem::size_of::<WGPUFutureWaitInfo>() - 16usize];
    ["Alignment of WGPUFutureWaitInfo"][::core::mem::align_of::<WGPUFutureWaitInfo>() - 8usize];
    ["Offset of field: WGPUFutureWaitInfo::future"]
        [::core::mem::offset_of!(WGPUFutureWaitInfo, future) - 0usize];
    ["Offset of field: WGPUFutureWaitInfo::completed"]
        [::core::mem::offset_of!(WGPUFutureWaitInfo, completed) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUImageCopyExternalTexture {
    pub nextInChain: *mut WGPUChainedStruct,
    pub externalTexture: WGPUExternalTexture,
    pub origin: WGPUOrigin3D,
    pub naturalSize: WGPUExtent2D,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUImageCopyExternalTexture"]
        [::core::mem::size_of::<WGPUImageCopyExternalTexture>() - 40usize];
    ["Alignment of WGPUImageCopyExternalTexture"]
        [::core::mem::align_of::<WGPUImageCopyExternalTexture>() - 8usize];
    ["Offset of field: WGPUImageCopyExternalTexture::nextInChain"]
        [::core::mem::offset_of!(WGPUImageCopyExternalTexture, nextInChain) - 0usize];
    ["Offset of field: WGPUImageCopyExternalTexture::externalTexture"]
        [::core::mem::offset_of!(WGPUImageCopyExternalTexture, externalTexture) - 8usize];
    ["Offset of field: WGPUImageCopyExternalTexture::origin"]
        [::core::mem::offset_of!(WGPUImageCopyExternalTexture, origin) - 16usize];
    ["Offset of field: WGPUImageCopyExternalTexture::naturalSize"]
        [::core::mem::offset_of!(WGPUImageCopyExternalTexture, naturalSize) - 28usize];
};
impl Default for WGPUImageCopyExternalTexture {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUInstanceDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub capabilities: WGPUInstanceCapabilities,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUInstanceDescriptor"][::core::mem::size_of::<WGPUInstanceDescriptor>() - 32usize];
    ["Alignment of WGPUInstanceDescriptor"]
        [::core::mem::align_of::<WGPUInstanceDescriptor>() - 8usize];
    ["Offset of field: WGPUInstanceDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUInstanceDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUInstanceDescriptor::capabilities"]
        [::core::mem::offset_of!(WGPUInstanceDescriptor, capabilities) - 8usize];
};
impl Default for WGPUInstanceDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPULimits {
    pub nextInChain: *mut WGPUChainedStruct,
    pub maxTextureDimension1D: u32,
    pub maxTextureDimension2D: u32,
    pub maxTextureDimension3D: u32,
    pub maxTextureArrayLayers: u32,
    pub maxBindGroups: u32,
    pub maxBindGroupsPlusVertexBuffers: u32,
    pub maxBindingsPerBindGroup: u32,
    pub maxDynamicUniformBuffersPerPipelineLayout: u32,
    pub maxDynamicStorageBuffersPerPipelineLayout: u32,
    pub maxSampledTexturesPerShaderStage: u32,
    pub maxSamplersPerShaderStage: u32,
    pub maxStorageBuffersPerShaderStage: u32,
    pub maxStorageTexturesPerShaderStage: u32,
    pub maxUniformBuffersPerShaderStage: u32,
    pub maxUniformBufferBindingSize: u64,
    pub maxStorageBufferBindingSize: u64,
    pub minUniformBufferOffsetAlignment: u32,
    pub minStorageBufferOffsetAlignment: u32,
    pub maxVertexBuffers: u32,
    pub maxBufferSize: u64,
    pub maxVertexAttributes: u32,
    pub maxVertexBufferArrayStride: u32,
    pub maxInterStageShaderVariables: u32,
    pub maxColorAttachments: u32,
    pub maxColorAttachmentBytesPerSample: u32,
    pub maxComputeWorkgroupStorageSize: u32,
    pub maxComputeInvocationsPerWorkgroup: u32,
    pub maxComputeWorkgroupSizeX: u32,
    pub maxComputeWorkgroupSizeY: u32,
    pub maxComputeWorkgroupSizeZ: u32,
    pub maxComputeWorkgroupsPerDimension: u32,
    pub maxImmediateSize: u32,
    pub maxStorageBuffersInVertexStage: u32,
    pub maxStorageTexturesInVertexStage: u32,
    pub maxStorageBuffersInFragmentStage: u32,
    pub maxStorageTexturesInFragmentStage: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPULimits"][::core::mem::size_of::<WGPULimits>() - 168usize];
    ["Alignment of WGPULimits"][::core::mem::align_of::<WGPULimits>() - 8usize];
    ["Offset of field: WGPULimits::nextInChain"]
        [::core::mem::offset_of!(WGPULimits, nextInChain) - 0usize];
    ["Offset of field: WGPULimits::maxTextureDimension1D"]
        [::core::mem::offset_of!(WGPULimits, maxTextureDimension1D) - 8usize];
    ["Offset of field: WGPULimits::maxTextureDimension2D"]
        [::core::mem::offset_of!(WGPULimits, maxTextureDimension2D) - 12usize];
    ["Offset of field: WGPULimits::maxTextureDimension3D"]
        [::core::mem::offset_of!(WGPULimits, maxTextureDimension3D) - 16usize];
    ["Offset of field: WGPULimits::maxTextureArrayLayers"]
        [::core::mem::offset_of!(WGPULimits, maxTextureArrayLayers) - 20usize];
    ["Offset of field: WGPULimits::maxBindGroups"]
        [::core::mem::offset_of!(WGPULimits, maxBindGroups) - 24usize];
    ["Offset of field: WGPULimits::maxBindGroupsPlusVertexBuffers"]
        [::core::mem::offset_of!(WGPULimits, maxBindGroupsPlusVertexBuffers) - 28usize];
    ["Offset of field: WGPULimits::maxBindingsPerBindGroup"]
        [::core::mem::offset_of!(WGPULimits, maxBindingsPerBindGroup) - 32usize];
    ["Offset of field: WGPULimits::maxDynamicUniformBuffersPerPipelineLayout"]
        [::core::mem::offset_of!(WGPULimits, maxDynamicUniformBuffersPerPipelineLayout) - 36usize];
    ["Offset of field: WGPULimits::maxDynamicStorageBuffersPerPipelineLayout"]
        [::core::mem::offset_of!(WGPULimits, maxDynamicStorageBuffersPerPipelineLayout) - 40usize];
    ["Offset of field: WGPULimits::maxSampledTexturesPerShaderStage"]
        [::core::mem::offset_of!(WGPULimits, maxSampledTexturesPerShaderStage) - 44usize];
    ["Offset of field: WGPULimits::maxSamplersPerShaderStage"]
        [::core::mem::offset_of!(WGPULimits, maxSamplersPerShaderStage) - 48usize];
    ["Offset of field: WGPULimits::maxStorageBuffersPerShaderStage"]
        [::core::mem::offset_of!(WGPULimits, maxStorageBuffersPerShaderStage) - 52usize];
    ["Offset of field: WGPULimits::maxStorageTexturesPerShaderStage"]
        [::core::mem::offset_of!(WGPULimits, maxStorageTexturesPerShaderStage) - 56usize];
    ["Offset of field: WGPULimits::maxUniformBuffersPerShaderStage"]
        [::core::mem::offset_of!(WGPULimits, maxUniformBuffersPerShaderStage) - 60usize];
    ["Offset of field: WGPULimits::maxUniformBufferBindingSize"]
        [::core::mem::offset_of!(WGPULimits, maxUniformBufferBindingSize) - 64usize];
    ["Offset of field: WGPULimits::maxStorageBufferBindingSize"]
        [::core::mem::offset_of!(WGPULimits, maxStorageBufferBindingSize) - 72usize];
    ["Offset of field: WGPULimits::minUniformBufferOffsetAlignment"]
        [::core::mem::offset_of!(WGPULimits, minUniformBufferOffsetAlignment) - 80usize];
    ["Offset of field: WGPULimits::minStorageBufferOffsetAlignment"]
        [::core::mem::offset_of!(WGPULimits, minStorageBufferOffsetAlignment) - 84usize];
    ["Offset of field: WGPULimits::maxVertexBuffers"]
        [::core::mem::offset_of!(WGPULimits, maxVertexBuffers) - 88usize];
    ["Offset of field: WGPULimits::maxBufferSize"]
        [::core::mem::offset_of!(WGPULimits, maxBufferSize) - 96usize];
    ["Offset of field: WGPULimits::maxVertexAttributes"]
        [::core::mem::offset_of!(WGPULimits, maxVertexAttributes) - 104usize];
    ["Offset of field: WGPULimits::maxVertexBufferArrayStride"]
        [::core::mem::offset_of!(WGPULimits, maxVertexBufferArrayStride) - 108usize];
    ["Offset of field: WGPULimits::maxInterStageShaderVariables"]
        [::core::mem::offset_of!(WGPULimits, maxInterStageShaderVariables) - 112usize];
    ["Offset of field: WGPULimits::maxColorAttachments"]
        [::core::mem::offset_of!(WGPULimits, maxColorAttachments) - 116usize];
    ["Offset of field: WGPULimits::maxColorAttachmentBytesPerSample"]
        [::core::mem::offset_of!(WGPULimits, maxColorAttachmentBytesPerSample) - 120usize];
    ["Offset of field: WGPULimits::maxComputeWorkgroupStorageSize"]
        [::core::mem::offset_of!(WGPULimits, maxComputeWorkgroupStorageSize) - 124usize];
    ["Offset of field: WGPULimits::maxComputeInvocationsPerWorkgroup"]
        [::core::mem::offset_of!(WGPULimits, maxComputeInvocationsPerWorkgroup) - 128usize];
    ["Offset of field: WGPULimits::maxComputeWorkgroupSizeX"]
        [::core::mem::offset_of!(WGPULimits, maxComputeWorkgroupSizeX) - 132usize];
    ["Offset of field: WGPULimits::maxComputeWorkgroupSizeY"]
        [::core::mem::offset_of!(WGPULimits, maxComputeWorkgroupSizeY) - 136usize];
    ["Offset of field: WGPULimits::maxComputeWorkgroupSizeZ"]
        [::core::mem::offset_of!(WGPULimits, maxComputeWorkgroupSizeZ) - 140usize];
    ["Offset of field: WGPULimits::maxComputeWorkgroupsPerDimension"]
        [::core::mem::offset_of!(WGPULimits, maxComputeWorkgroupsPerDimension) - 144usize];
    ["Offset of field: WGPULimits::maxImmediateSize"]
        [::core::mem::offset_of!(WGPULimits, maxImmediateSize) - 148usize];
    ["Offset of field: WGPULimits::maxStorageBuffersInVertexStage"]
        [::core::mem::offset_of!(WGPULimits, maxStorageBuffersInVertexStage) - 152usize];
    ["Offset of field: WGPULimits::maxStorageTexturesInVertexStage"]
        [::core::mem::offset_of!(WGPULimits, maxStorageTexturesInVertexStage) - 156usize];
    ["Offset of field: WGPULimits::maxStorageBuffersInFragmentStage"]
        [::core::mem::offset_of!(WGPULimits, maxStorageBuffersInFragmentStage) - 160usize];
    ["Offset of field: WGPULimits::maxStorageTexturesInFragmentStage"]
        [::core::mem::offset_of!(WGPULimits, maxStorageTexturesInFragmentStage) - 164usize];
};
impl Default for WGPULimits {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPipelineLayoutPixelLocalStorage {
    pub chain: WGPUChainedStruct,
    pub totalPixelLocalStorageSize: u64,
    pub storageAttachmentCount: usize,
    pub storageAttachments: *const WGPUPipelineLayoutStorageAttachment,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUPipelineLayoutPixelLocalStorage"]
        [::core::mem::size_of::<WGPUPipelineLayoutPixelLocalStorage>() - 40usize];
    ["Alignment of WGPUPipelineLayoutPixelLocalStorage"]
        [::core::mem::align_of::<WGPUPipelineLayoutPixelLocalStorage>() - 8usize];
    ["Offset of field: WGPUPipelineLayoutPixelLocalStorage::chain"]
        [::core::mem::offset_of!(WGPUPipelineLayoutPixelLocalStorage, chain) - 0usize];
    ["Offset of field: WGPUPipelineLayoutPixelLocalStorage::totalPixelLocalStorageSize"][::core::mem::offset_of!(
        WGPUPipelineLayoutPixelLocalStorage,
        totalPixelLocalStorageSize
    )
        - 16usize];
    ["Offset of field: WGPUPipelineLayoutPixelLocalStorage::storageAttachmentCount"][::core::mem::offset_of!(
        WGPUPipelineLayoutPixelLocalStorage,
        storageAttachmentCount
    ) - 24usize];
    ["Offset of field: WGPUPipelineLayoutPixelLocalStorage::storageAttachments"][::core::mem::offset_of!(
        WGPUPipelineLayoutPixelLocalStorage,
        storageAttachments
    ) - 32usize];
};
impl Default for WGPUPipelineLayoutPixelLocalStorage {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct WGPURenderPassColorAttachment {
    pub nextInChain: *mut WGPUChainedStruct,
    pub view: WGPUTextureView,
    pub depthSlice: u32,
    pub resolveTarget: WGPUTextureView,
    pub loadOp: WGPULoadOp,
    pub storeOp: WGPUStoreOp,
    pub clearValue: WGPUColor,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderPassColorAttachment"]
        [::core::mem::size_of::<WGPURenderPassColorAttachment>() - 72usize];
    ["Alignment of WGPURenderPassColorAttachment"]
        [::core::mem::align_of::<WGPURenderPassColorAttachment>() - 8usize];
    ["Offset of field: WGPURenderPassColorAttachment::nextInChain"]
        [::core::mem::offset_of!(WGPURenderPassColorAttachment, nextInChain) - 0usize];
    ["Offset of field: WGPURenderPassColorAttachment::view"]
        [::core::mem::offset_of!(WGPURenderPassColorAttachment, view) - 8usize];
    ["Offset of field: WGPURenderPassColorAttachment::depthSlice"]
        [::core::mem::offset_of!(WGPURenderPassColorAttachment, depthSlice) - 16usize];
    ["Offset of field: WGPURenderPassColorAttachment::resolveTarget"]
        [::core::mem::offset_of!(WGPURenderPassColorAttachment, resolveTarget) - 24usize];
    ["Offset of field: WGPURenderPassColorAttachment::loadOp"]
        [::core::mem::offset_of!(WGPURenderPassColorAttachment, loadOp) - 32usize];
    ["Offset of field: WGPURenderPassColorAttachment::storeOp"]
        [::core::mem::offset_of!(WGPURenderPassColorAttachment, storeOp) - 36usize];
    ["Offset of field: WGPURenderPassColorAttachment::clearValue"]
        [::core::mem::offset_of!(WGPURenderPassColorAttachment, clearValue) - 40usize];
};
impl Default for WGPURenderPassColorAttachment {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct WGPURenderPassStorageAttachment {
    pub nextInChain: *mut WGPUChainedStruct,
    pub offset: u64,
    pub storage: WGPUTextureView,
    pub loadOp: WGPULoadOp,
    pub storeOp: WGPUStoreOp,
    pub clearValue: WGPUColor,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderPassStorageAttachment"]
        [::core::mem::size_of::<WGPURenderPassStorageAttachment>() - 64usize];
    ["Alignment of WGPURenderPassStorageAttachment"]
        [::core::mem::align_of::<WGPURenderPassStorageAttachment>() - 8usize];
    ["Offset of field: WGPURenderPassStorageAttachment::nextInChain"]
        [::core::mem::offset_of!(WGPURenderPassStorageAttachment, nextInChain) - 0usize];
    ["Offset of field: WGPURenderPassStorageAttachment::offset"]
        [::core::mem::offset_of!(WGPURenderPassStorageAttachment, offset) - 8usize];
    ["Offset of field: WGPURenderPassStorageAttachment::storage"]
        [::core::mem::offset_of!(WGPURenderPassStorageAttachment, storage) - 16usize];
    ["Offset of field: WGPURenderPassStorageAttachment::loadOp"]
        [::core::mem::offset_of!(WGPURenderPassStorageAttachment, loadOp) - 24usize];
    ["Offset of field: WGPURenderPassStorageAttachment::storeOp"]
        [::core::mem::offset_of!(WGPURenderPassStorageAttachment, storeOp) - 28usize];
    ["Offset of field: WGPURenderPassStorageAttachment::clearValue"]
        [::core::mem::offset_of!(WGPURenderPassStorageAttachment, clearValue) - 32usize];
};
impl Default for WGPURenderPassStorageAttachment {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURequestAdapterOptions {
    pub nextInChain: *mut WGPUChainedStruct,
    pub featureLevel: WGPUFeatureLevel,
    pub powerPreference: WGPUPowerPreference,
    pub forceFallbackAdapter: WGPUBool,
    pub backendType: WGPUBackendType,
    pub compatibleSurface: WGPUSurface,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURequestAdapterOptions"]
        [::core::mem::size_of::<WGPURequestAdapterOptions>() - 32usize];
    ["Alignment of WGPURequestAdapterOptions"]
        [::core::mem::align_of::<WGPURequestAdapterOptions>() - 8usize];
    ["Offset of field: WGPURequestAdapterOptions::nextInChain"]
        [::core::mem::offset_of!(WGPURequestAdapterOptions, nextInChain) - 0usize];
    ["Offset of field: WGPURequestAdapterOptions::featureLevel"]
        [::core::mem::offset_of!(WGPURequestAdapterOptions, featureLevel) - 8usize];
    ["Offset of field: WGPURequestAdapterOptions::powerPreference"]
        [::core::mem::offset_of!(WGPURequestAdapterOptions, powerPreference) - 12usize];
    ["Offset of field: WGPURequestAdapterOptions::forceFallbackAdapter"]
        [::core::mem::offset_of!(WGPURequestAdapterOptions, forceFallbackAdapter) - 16usize];
    ["Offset of field: WGPURequestAdapterOptions::backendType"]
        [::core::mem::offset_of!(WGPURequestAdapterOptions, backendType) - 20usize];
    ["Offset of field: WGPURequestAdapterOptions::compatibleSurface"]
        [::core::mem::offset_of!(WGPURequestAdapterOptions, compatibleSurface) - 24usize];
};
impl Default for WGPURequestAdapterOptions {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
pub struct WGPUSamplerDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub addressModeU: WGPUAddressMode,
    pub addressModeV: WGPUAddressMode,
    pub addressModeW: WGPUAddressMode,
    pub magFilter: WGPUFilterMode,
    pub minFilter: WGPUFilterMode,
    pub mipmapFilter: WGPUMipmapFilterMode,
    pub lodMinClamp: f32,
    pub lodMaxClamp: f32,
    pub compare: WGPUCompareFunction,
    pub maxAnisotropy: u16,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSamplerDescriptor"][::core::mem::size_of::<WGPUSamplerDescriptor>() - 64usize];
    ["Alignment of WGPUSamplerDescriptor"]
        [::core::mem::align_of::<WGPUSamplerDescriptor>() - 8usize];
    ["Offset of field: WGPUSamplerDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUSamplerDescriptor::label"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, label) - 8usize];
    ["Offset of field: WGPUSamplerDescriptor::addressModeU"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, addressModeU) - 24usize];
    ["Offset of field: WGPUSamplerDescriptor::addressModeV"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, addressModeV) - 28usize];
    ["Offset of field: WGPUSamplerDescriptor::addressModeW"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, addressModeW) - 32usize];
    ["Offset of field: WGPUSamplerDescriptor::magFilter"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, magFilter) - 36usize];
    ["Offset of field: WGPUSamplerDescriptor::minFilter"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, minFilter) - 40usize];
    ["Offset of field: WGPUSamplerDescriptor::mipmapFilter"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, mipmapFilter) - 44usize];
    ["Offset of field: WGPUSamplerDescriptor::lodMinClamp"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, lodMinClamp) - 48usize];
    ["Offset of field: WGPUSamplerDescriptor::lodMaxClamp"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, lodMaxClamp) - 52usize];
    ["Offset of field: WGPUSamplerDescriptor::compare"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, compare) - 56usize];
    ["Offset of field: WGPUSamplerDescriptor::maxAnisotropy"]
        [::core::mem::offset_of!(WGPUSamplerDescriptor, maxAnisotropy) - 60usize];
};
impl Default for WGPUSamplerDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUShaderModuleDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUShaderModuleDescriptor"]
        [::core::mem::size_of::<WGPUShaderModuleDescriptor>() - 24usize];
    ["Alignment of WGPUShaderModuleDescriptor"]
        [::core::mem::align_of::<WGPUShaderModuleDescriptor>() - 8usize];
    ["Offset of field: WGPUShaderModuleDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUShaderModuleDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUShaderModuleDescriptor::label"]
        [::core::mem::offset_of!(WGPUShaderModuleDescriptor, label) - 8usize];
};
impl Default for WGPUShaderModuleDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceDescriptor"]
        [::core::mem::size_of::<WGPUSharedFenceDescriptor>() - 24usize];
    ["Alignment of WGPUSharedFenceDescriptor"]
        [::core::mem::align_of::<WGPUSharedFenceDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedFenceDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUSharedFenceDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUSharedFenceDescriptor::label"]
        [::core::mem::offset_of!(WGPUSharedFenceDescriptor, label) - 8usize];
};
impl Default for WGPUSharedFenceDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedFenceExportInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub type_: WGPUSharedFenceType,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedFenceExportInfo"]
        [::core::mem::size_of::<WGPUSharedFenceExportInfo>() - 16usize];
    ["Alignment of WGPUSharedFenceExportInfo"]
        [::core::mem::align_of::<WGPUSharedFenceExportInfo>() - 8usize];
    ["Offset of field: WGPUSharedFenceExportInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUSharedFenceExportInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUSharedFenceExportInfo::type_"]
        [::core::mem::offset_of!(WGPUSharedFenceExportInfo, type_) - 8usize];
};
impl Default for WGPUSharedFenceExportInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryAHardwareBufferProperties {
    pub chain: WGPUChainedStruct,
    pub yCbCrInfo: WGPUYCbCrVkDescriptor,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryAHardwareBufferProperties"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryAHardwareBufferProperties>() - 88usize];
    ["Alignment of WGPUSharedTextureMemoryAHardwareBufferProperties"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryAHardwareBufferProperties>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryAHardwareBufferProperties::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryAHardwareBufferProperties, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryAHardwareBufferProperties::yCbCrInfo"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryAHardwareBufferProperties,
        yCbCrInfo
    ) - 16usize];
};
impl Default for WGPUSharedTextureMemoryAHardwareBufferProperties {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryBeginAccessDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub concurrentRead: WGPUBool,
    pub initialized: WGPUBool,
    pub fenceCount: usize,
    pub fences: *const WGPUSharedFence,
    pub signaledValues: *const u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryBeginAccessDescriptor"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryBeginAccessDescriptor>() - 40usize];
    ["Alignment of WGPUSharedTextureMemoryBeginAccessDescriptor"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryBeginAccessDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryBeginAccessDescriptor::nextInChain"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryBeginAccessDescriptor,
        nextInChain
    ) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryBeginAccessDescriptor::concurrentRead"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryBeginAccessDescriptor,
        concurrentRead
    ) - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryBeginAccessDescriptor::initialized"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryBeginAccessDescriptor,
        initialized
    ) - 12usize];
    ["Offset of field: WGPUSharedTextureMemoryBeginAccessDescriptor::fenceCount"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryBeginAccessDescriptor,
        fenceCount
    ) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryBeginAccessDescriptor::fences"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryBeginAccessDescriptor, fences) - 24usize];
    ["Offset of field: WGPUSharedTextureMemoryBeginAccessDescriptor::signaledValues"][::core::mem::offset_of!(
        WGPUSharedTextureMemoryBeginAccessDescriptor,
        signaledValues
    ) - 32usize];
};
impl Default for WGPUSharedTextureMemoryBeginAccessDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryDmaBufDescriptor {
    pub chain: WGPUChainedStruct,
    pub size: WGPUExtent3D,
    pub drmFormat: u32,
    pub drmModifier: u64,
    pub planeCount: usize,
    pub planes: *const WGPUSharedTextureMemoryDmaBufPlane,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryDmaBufDescriptor"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryDmaBufDescriptor>() - 56usize];
    ["Alignment of WGPUSharedTextureMemoryDmaBufDescriptor"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryDmaBufDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryDmaBufDescriptor::chain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDmaBufDescriptor, chain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryDmaBufDescriptor::size"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDmaBufDescriptor, size) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryDmaBufDescriptor::drmFormat"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDmaBufDescriptor, drmFormat) - 28usize];
    ["Offset of field: WGPUSharedTextureMemoryDmaBufDescriptor::drmModifier"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDmaBufDescriptor, drmModifier) - 32usize];
    ["Offset of field: WGPUSharedTextureMemoryDmaBufDescriptor::planeCount"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDmaBufDescriptor, planeCount) - 40usize];
    ["Offset of field: WGPUSharedTextureMemoryDmaBufDescriptor::planes"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDmaBufDescriptor, planes) - 48usize];
};
impl Default for WGPUSharedTextureMemoryDmaBufDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryEndAccessState {
    pub nextInChain: *mut WGPUChainedStruct,
    pub initialized: WGPUBool,
    pub fenceCount: usize,
    pub fences: *const WGPUSharedFence,
    pub signaledValues: *const u64,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryEndAccessState"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryEndAccessState>() - 40usize];
    ["Alignment of WGPUSharedTextureMemoryEndAccessState"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryEndAccessState>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryEndAccessState::nextInChain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryEndAccessState, nextInChain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryEndAccessState::initialized"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryEndAccessState, initialized) - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryEndAccessState::fenceCount"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryEndAccessState, fenceCount) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryEndAccessState::fences"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryEndAccessState, fences) - 24usize];
    ["Offset of field: WGPUSharedTextureMemoryEndAccessState::signaledValues"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryEndAccessState, signaledValues) - 32usize];
};
impl Default for WGPUSharedTextureMemoryEndAccessState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSurfaceDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSurfaceDescriptor"][::core::mem::size_of::<WGPUSurfaceDescriptor>() - 24usize];
    ["Alignment of WGPUSurfaceDescriptor"]
        [::core::mem::align_of::<WGPUSurfaceDescriptor>() - 8usize];
    ["Offset of field: WGPUSurfaceDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUSurfaceDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUSurfaceDescriptor::label"]
        [::core::mem::offset_of!(WGPUSurfaceDescriptor, label) - 8usize];
};
impl Default for WGPUSurfaceDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTexelCopyBufferInfo {
    pub layout: WGPUTexelCopyBufferLayout,
    pub buffer: WGPUBuffer,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUTexelCopyBufferInfo"]
        [::core::mem::size_of::<WGPUTexelCopyBufferInfo>() - 24usize];
    ["Alignment of WGPUTexelCopyBufferInfo"]
        [::core::mem::align_of::<WGPUTexelCopyBufferInfo>() - 8usize];
    ["Offset of field: WGPUTexelCopyBufferInfo::layout"]
        [::core::mem::offset_of!(WGPUTexelCopyBufferInfo, layout) - 0usize];
    ["Offset of field: WGPUTexelCopyBufferInfo::buffer"]
        [::core::mem::offset_of!(WGPUTexelCopyBufferInfo, buffer) - 16usize];
};
impl Default for WGPUTexelCopyBufferInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUTexelCopyTextureInfo {
    pub texture: WGPUTexture,
    pub mipLevel: u32,
    pub origin: WGPUOrigin3D,
    pub aspect: WGPUTextureAspect,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUTexelCopyTextureInfo"]
        [::core::mem::size_of::<WGPUTexelCopyTextureInfo>() - 32usize];
    ["Alignment of WGPUTexelCopyTextureInfo"]
        [::core::mem::align_of::<WGPUTexelCopyTextureInfo>() - 8usize];
    ["Offset of field: WGPUTexelCopyTextureInfo::texture"]
        [::core::mem::offset_of!(WGPUTexelCopyTextureInfo, texture) - 0usize];
    ["Offset of field: WGPUTexelCopyTextureInfo::mipLevel"]
        [::core::mem::offset_of!(WGPUTexelCopyTextureInfo, mipLevel) - 8usize];
    ["Offset of field: WGPUTexelCopyTextureInfo::origin"]
        [::core::mem::offset_of!(WGPUTexelCopyTextureInfo, origin) - 12usize];
    ["Offset of field: WGPUTexelCopyTextureInfo::aspect"]
        [::core::mem::offset_of!(WGPUTexelCopyTextureInfo, aspect) - 24usize];
};
impl Default for WGPUTexelCopyTextureInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUTextureDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub usage: WGPUTextureUsage,
    pub dimension: WGPUTextureDimension,
    pub size: WGPUExtent3D,
    pub format: WGPUTextureFormat,
    pub mipLevelCount: u32,
    pub sampleCount: u32,
    pub viewFormatCount: usize,
    pub viewFormats: *const WGPUTextureFormat,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUTextureDescriptor"][::core::mem::size_of::<WGPUTextureDescriptor>() - 80usize];
    ["Alignment of WGPUTextureDescriptor"]
        [::core::mem::align_of::<WGPUTextureDescriptor>() - 8usize];
    ["Offset of field: WGPUTextureDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUTextureDescriptor::label"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, label) - 8usize];
    ["Offset of field: WGPUTextureDescriptor::usage"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, usage) - 24usize];
    ["Offset of field: WGPUTextureDescriptor::dimension"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, dimension) - 32usize];
    ["Offset of field: WGPUTextureDescriptor::size"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, size) - 36usize];
    ["Offset of field: WGPUTextureDescriptor::format"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, format) - 48usize];
    ["Offset of field: WGPUTextureDescriptor::mipLevelCount"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, mipLevelCount) - 52usize];
    ["Offset of field: WGPUTextureDescriptor::sampleCount"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, sampleCount) - 56usize];
    ["Offset of field: WGPUTextureDescriptor::viewFormatCount"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, viewFormatCount) - 64usize];
    ["Offset of field: WGPUTextureDescriptor::viewFormats"]
        [::core::mem::offset_of!(WGPUTextureDescriptor, viewFormats) - 72usize];
};
impl Default for WGPUTextureDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUTextureViewDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub format: WGPUTextureFormat,
    pub dimension: WGPUTextureViewDimension,
    pub baseMipLevel: u32,
    pub mipLevelCount: u32,
    pub baseArrayLayer: u32,
    pub arrayLayerCount: u32,
    pub aspect: WGPUTextureAspect,
    pub usage: WGPUTextureUsage,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUTextureViewDescriptor"]
        [::core::mem::size_of::<WGPUTextureViewDescriptor>() - 64usize];
    ["Alignment of WGPUTextureViewDescriptor"]
        [::core::mem::align_of::<WGPUTextureViewDescriptor>() - 8usize];
    ["Offset of field: WGPUTextureViewDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUTextureViewDescriptor::label"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, label) - 8usize];
    ["Offset of field: WGPUTextureViewDescriptor::format"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, format) - 24usize];
    ["Offset of field: WGPUTextureViewDescriptor::dimension"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, dimension) - 28usize];
    ["Offset of field: WGPUTextureViewDescriptor::baseMipLevel"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, baseMipLevel) - 32usize];
    ["Offset of field: WGPUTextureViewDescriptor::mipLevelCount"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, mipLevelCount) - 36usize];
    ["Offset of field: WGPUTextureViewDescriptor::baseArrayLayer"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, baseArrayLayer) - 40usize];
    ["Offset of field: WGPUTextureViewDescriptor::arrayLayerCount"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, arrayLayerCount) - 44usize];
    ["Offset of field: WGPUTextureViewDescriptor::aspect"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, aspect) - 48usize];
    ["Offset of field: WGPUTextureViewDescriptor::usage"]
        [::core::mem::offset_of!(WGPUTextureViewDescriptor, usage) - 56usize];
};
impl Default for WGPUTextureViewDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUVertexBufferLayout {
    pub nextInChain: *mut WGPUChainedStruct,
    pub stepMode: WGPUVertexStepMode,
    pub arrayStride: u64,
    pub attributeCount: usize,
    pub attributes: *const WGPUVertexAttribute,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUVertexBufferLayout"][::core::mem::size_of::<WGPUVertexBufferLayout>() - 40usize];
    ["Alignment of WGPUVertexBufferLayout"]
        [::core::mem::align_of::<WGPUVertexBufferLayout>() - 8usize];
    ["Offset of field: WGPUVertexBufferLayout::nextInChain"]
        [::core::mem::offset_of!(WGPUVertexBufferLayout, nextInChain) - 0usize];
    ["Offset of field: WGPUVertexBufferLayout::stepMode"]
        [::core::mem::offset_of!(WGPUVertexBufferLayout, stepMode) - 8usize];
    ["Offset of field: WGPUVertexBufferLayout::arrayStride"]
        [::core::mem::offset_of!(WGPUVertexBufferLayout, arrayStride) - 16usize];
    ["Offset of field: WGPUVertexBufferLayout::attributeCount"]
        [::core::mem::offset_of!(WGPUVertexBufferLayout, attributeCount) - 24usize];
    ["Offset of field: WGPUVertexBufferLayout::attributes"]
        [::core::mem::offset_of!(WGPUVertexBufferLayout, attributes) - 32usize];
};
impl Default for WGPUVertexBufferLayout {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUAdapterInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub vendor: WGPUStringView,
    pub architecture: WGPUStringView,
    pub device: WGPUStringView,
    pub description: WGPUStringView,
    pub backendType: WGPUBackendType,
    pub adapterType: WGPUAdapterType,
    pub vendorID: u32,
    pub deviceID: u32,
    pub subgroupMinSize: u32,
    pub subgroupMaxSize: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUAdapterInfo"][::core::mem::size_of::<WGPUAdapterInfo>() - 96usize];
    ["Alignment of WGPUAdapterInfo"][::core::mem::align_of::<WGPUAdapterInfo>() - 8usize];
    ["Offset of field: WGPUAdapterInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUAdapterInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUAdapterInfo::vendor"]
        [::core::mem::offset_of!(WGPUAdapterInfo, vendor) - 8usize];
    ["Offset of field: WGPUAdapterInfo::architecture"]
        [::core::mem::offset_of!(WGPUAdapterInfo, architecture) - 24usize];
    ["Offset of field: WGPUAdapterInfo::device"]
        [::core::mem::offset_of!(WGPUAdapterInfo, device) - 40usize];
    ["Offset of field: WGPUAdapterInfo::description"]
        [::core::mem::offset_of!(WGPUAdapterInfo, description) - 56usize];
    ["Offset of field: WGPUAdapterInfo::backendType"]
        [::core::mem::offset_of!(WGPUAdapterInfo, backendType) - 72usize];
    ["Offset of field: WGPUAdapterInfo::adapterType"]
        [::core::mem::offset_of!(WGPUAdapterInfo, adapterType) - 76usize];
    ["Offset of field: WGPUAdapterInfo::vendorID"]
        [::core::mem::offset_of!(WGPUAdapterInfo, vendorID) - 80usize];
    ["Offset of field: WGPUAdapterInfo::deviceID"]
        [::core::mem::offset_of!(WGPUAdapterInfo, deviceID) - 84usize];
    ["Offset of field: WGPUAdapterInfo::subgroupMinSize"]
        [::core::mem::offset_of!(WGPUAdapterInfo, subgroupMinSize) - 88usize];
    ["Offset of field: WGPUAdapterInfo::subgroupMaxSize"]
        [::core::mem::offset_of!(WGPUAdapterInfo, subgroupMaxSize) - 92usize];
};
impl Default for WGPUAdapterInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBindGroupDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub layout: WGPUBindGroupLayout,
    pub entryCount: usize,
    pub entries: *const WGPUBindGroupEntry,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBindGroupDescriptor"]
        [::core::mem::size_of::<WGPUBindGroupDescriptor>() - 48usize];
    ["Alignment of WGPUBindGroupDescriptor"]
        [::core::mem::align_of::<WGPUBindGroupDescriptor>() - 8usize];
    ["Offset of field: WGPUBindGroupDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUBindGroupDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUBindGroupDescriptor::label"]
        [::core::mem::offset_of!(WGPUBindGroupDescriptor, label) - 8usize];
    ["Offset of field: WGPUBindGroupDescriptor::layout"]
        [::core::mem::offset_of!(WGPUBindGroupDescriptor, layout) - 24usize];
    ["Offset of field: WGPUBindGroupDescriptor::entryCount"]
        [::core::mem::offset_of!(WGPUBindGroupDescriptor, entryCount) - 32usize];
    ["Offset of field: WGPUBindGroupDescriptor::entries"]
        [::core::mem::offset_of!(WGPUBindGroupDescriptor, entries) - 40usize];
};
impl Default for WGPUBindGroupDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUBindGroupLayoutDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub entryCount: usize,
    pub entries: *const WGPUBindGroupLayoutEntry,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUBindGroupLayoutDescriptor"]
        [::core::mem::size_of::<WGPUBindGroupLayoutDescriptor>() - 40usize];
    ["Alignment of WGPUBindGroupLayoutDescriptor"]
        [::core::mem::align_of::<WGPUBindGroupLayoutDescriptor>() - 8usize];
    ["Offset of field: WGPUBindGroupLayoutDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUBindGroupLayoutDescriptor::label"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutDescriptor, label) - 8usize];
    ["Offset of field: WGPUBindGroupLayoutDescriptor::entryCount"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutDescriptor, entryCount) - 24usize];
    ["Offset of field: WGPUBindGroupLayoutDescriptor::entries"]
        [::core::mem::offset_of!(WGPUBindGroupLayoutDescriptor, entries) - 32usize];
};
impl Default for WGPUBindGroupLayoutDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUColorTargetState {
    pub nextInChain: *mut WGPUChainedStruct,
    pub format: WGPUTextureFormat,
    pub blend: *const WGPUBlendState,
    pub writeMask: WGPUColorWriteMask,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUColorTargetState"][::core::mem::size_of::<WGPUColorTargetState>() - 32usize];
    ["Alignment of WGPUColorTargetState"][::core::mem::align_of::<WGPUColorTargetState>() - 8usize];
    ["Offset of field: WGPUColorTargetState::nextInChain"]
        [::core::mem::offset_of!(WGPUColorTargetState, nextInChain) - 0usize];
    ["Offset of field: WGPUColorTargetState::format"]
        [::core::mem::offset_of!(WGPUColorTargetState, format) - 8usize];
    ["Offset of field: WGPUColorTargetState::blend"]
        [::core::mem::offset_of!(WGPUColorTargetState, blend) - 16usize];
    ["Offset of field: WGPUColorTargetState::writeMask"]
        [::core::mem::offset_of!(WGPUColorTargetState, writeMask) - 24usize];
};
impl Default for WGPUColorTargetState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUCompilationInfo {
    pub nextInChain: *mut WGPUChainedStruct,
    pub messageCount: usize,
    pub messages: *const WGPUCompilationMessage,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUCompilationInfo"][::core::mem::size_of::<WGPUCompilationInfo>() - 24usize];
    ["Alignment of WGPUCompilationInfo"][::core::mem::align_of::<WGPUCompilationInfo>() - 8usize];
    ["Offset of field: WGPUCompilationInfo::nextInChain"]
        [::core::mem::offset_of!(WGPUCompilationInfo, nextInChain) - 0usize];
    ["Offset of field: WGPUCompilationInfo::messageCount"]
        [::core::mem::offset_of!(WGPUCompilationInfo, messageCount) - 8usize];
    ["Offset of field: WGPUCompilationInfo::messages"]
        [::core::mem::offset_of!(WGPUCompilationInfo, messages) - 16usize];
};
impl Default for WGPUCompilationInfo {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUComputePipelineDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub layout: WGPUPipelineLayout,
    pub compute: WGPUComputeState,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUComputePipelineDescriptor"]
        [::core::mem::size_of::<WGPUComputePipelineDescriptor>() - 80usize];
    ["Alignment of WGPUComputePipelineDescriptor"]
        [::core::mem::align_of::<WGPUComputePipelineDescriptor>() - 8usize];
    ["Offset of field: WGPUComputePipelineDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUComputePipelineDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUComputePipelineDescriptor::label"]
        [::core::mem::offset_of!(WGPUComputePipelineDescriptor, label) - 8usize];
    ["Offset of field: WGPUComputePipelineDescriptor::layout"]
        [::core::mem::offset_of!(WGPUComputePipelineDescriptor, layout) - 24usize];
    ["Offset of field: WGPUComputePipelineDescriptor::compute"]
        [::core::mem::offset_of!(WGPUComputePipelineDescriptor, compute) - 32usize];
};
impl Default for WGPUComputePipelineDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDawnFormatCapabilities {
    pub nextInChain: *mut WGPUChainedStruct,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDawnFormatCapabilities"]
        [::core::mem::size_of::<WGPUDawnFormatCapabilities>() - 8usize];
    ["Alignment of WGPUDawnFormatCapabilities"]
        [::core::mem::align_of::<WGPUDawnFormatCapabilities>() - 8usize];
    ["Offset of field: WGPUDawnFormatCapabilities::nextInChain"]
        [::core::mem::offset_of!(WGPUDawnFormatCapabilities, nextInChain) - 0usize];
};
impl Default for WGPUDawnFormatCapabilities {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUDeviceDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub requiredFeatureCount: usize,
    pub requiredFeatures: *const WGPUFeatureName,
    pub requiredLimits: *const WGPULimits,
    pub defaultQueue: WGPUQueueDescriptor,
    pub deviceLostCallbackInfo: WGPUDeviceLostCallbackInfo,
    pub uncapturedErrorCallbackInfo: WGPUUncapturedErrorCallbackInfo,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUDeviceDescriptor"][::core::mem::size_of::<WGPUDeviceDescriptor>() - 144usize];
    ["Alignment of WGPUDeviceDescriptor"][::core::mem::align_of::<WGPUDeviceDescriptor>() - 8usize];
    ["Offset of field: WGPUDeviceDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUDeviceDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUDeviceDescriptor::label"]
        [::core::mem::offset_of!(WGPUDeviceDescriptor, label) - 8usize];
    ["Offset of field: WGPUDeviceDescriptor::requiredFeatureCount"]
        [::core::mem::offset_of!(WGPUDeviceDescriptor, requiredFeatureCount) - 24usize];
    ["Offset of field: WGPUDeviceDescriptor::requiredFeatures"]
        [::core::mem::offset_of!(WGPUDeviceDescriptor, requiredFeatures) - 32usize];
    ["Offset of field: WGPUDeviceDescriptor::requiredLimits"]
        [::core::mem::offset_of!(WGPUDeviceDescriptor, requiredLimits) - 40usize];
    ["Offset of field: WGPUDeviceDescriptor::defaultQueue"]
        [::core::mem::offset_of!(WGPUDeviceDescriptor, defaultQueue) - 48usize];
    ["Offset of field: WGPUDeviceDescriptor::deviceLostCallbackInfo"]
        [::core::mem::offset_of!(WGPUDeviceDescriptor, deviceLostCallbackInfo) - 72usize];
    ["Offset of field: WGPUDeviceDescriptor::uncapturedErrorCallbackInfo"]
        [::core::mem::offset_of!(WGPUDeviceDescriptor, uncapturedErrorCallbackInfo) - 112usize];
};
impl Default for WGPUDeviceDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUPipelineLayoutDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub bindGroupLayoutCount: usize,
    pub bindGroupLayouts: *const WGPUBindGroupLayout,
    pub immediateSize: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUPipelineLayoutDescriptor"]
        [::core::mem::size_of::<WGPUPipelineLayoutDescriptor>() - 48usize];
    ["Alignment of WGPUPipelineLayoutDescriptor"]
        [::core::mem::align_of::<WGPUPipelineLayoutDescriptor>() - 8usize];
    ["Offset of field: WGPUPipelineLayoutDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUPipelineLayoutDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUPipelineLayoutDescriptor::label"]
        [::core::mem::offset_of!(WGPUPipelineLayoutDescriptor, label) - 8usize];
    ["Offset of field: WGPUPipelineLayoutDescriptor::bindGroupLayoutCount"]
        [::core::mem::offset_of!(WGPUPipelineLayoutDescriptor, bindGroupLayoutCount) - 24usize];
    ["Offset of field: WGPUPipelineLayoutDescriptor::bindGroupLayouts"]
        [::core::mem::offset_of!(WGPUPipelineLayoutDescriptor, bindGroupLayouts) - 32usize];
    ["Offset of field: WGPUPipelineLayoutDescriptor::immediateSize"]
        [::core::mem::offset_of!(WGPUPipelineLayoutDescriptor, immediateSize) - 40usize];
};
impl Default for WGPUPipelineLayoutDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURenderPassPixelLocalStorage {
    pub chain: WGPUChainedStruct,
    pub totalPixelLocalStorageSize: u64,
    pub storageAttachmentCount: usize,
    pub storageAttachments: *const WGPURenderPassStorageAttachment,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderPassPixelLocalStorage"]
        [::core::mem::size_of::<WGPURenderPassPixelLocalStorage>() - 40usize];
    ["Alignment of WGPURenderPassPixelLocalStorage"]
        [::core::mem::align_of::<WGPURenderPassPixelLocalStorage>() - 8usize];
    ["Offset of field: WGPURenderPassPixelLocalStorage::chain"]
        [::core::mem::offset_of!(WGPURenderPassPixelLocalStorage, chain) - 0usize];
    ["Offset of field: WGPURenderPassPixelLocalStorage::totalPixelLocalStorageSize"][::core::mem::offset_of!(
        WGPURenderPassPixelLocalStorage,
        totalPixelLocalStorageSize
    ) - 16usize];
    ["Offset of field: WGPURenderPassPixelLocalStorage::storageAttachmentCount"][::core::mem::offset_of!(
        WGPURenderPassPixelLocalStorage,
        storageAttachmentCount
    ) - 24usize];
    ["Offset of field: WGPURenderPassPixelLocalStorage::storageAttachments"]
        [::core::mem::offset_of!(WGPURenderPassPixelLocalStorage, storageAttachments) - 32usize];
};
impl Default for WGPURenderPassPixelLocalStorage {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUSharedTextureMemoryDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryDescriptor"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryDescriptor>() - 24usize];
    ["Alignment of WGPUSharedTextureMemoryDescriptor"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryDescriptor>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryDescriptor::label"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryDescriptor, label) - 8usize];
};
impl Default for WGPUSharedTextureMemoryDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
pub struct WGPUSharedTextureMemoryProperties {
    pub nextInChain: *mut WGPUChainedStruct,
    pub usage: WGPUTextureUsage,
    pub size: WGPUExtent3D,
    pub format: WGPUTextureFormat,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUSharedTextureMemoryProperties"]
        [::core::mem::size_of::<WGPUSharedTextureMemoryProperties>() - 32usize];
    ["Alignment of WGPUSharedTextureMemoryProperties"]
        [::core::mem::align_of::<WGPUSharedTextureMemoryProperties>() - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryProperties::nextInChain"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryProperties, nextInChain) - 0usize];
    ["Offset of field: WGPUSharedTextureMemoryProperties::usage"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryProperties, usage) - 8usize];
    ["Offset of field: WGPUSharedTextureMemoryProperties::size"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryProperties, size) - 16usize];
    ["Offset of field: WGPUSharedTextureMemoryProperties::format"]
        [::core::mem::offset_of!(WGPUSharedTextureMemoryProperties, format) - 28usize];
};
impl Default for WGPUSharedTextureMemoryProperties {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUVertexState {
    pub nextInChain: *mut WGPUChainedStruct,
    pub module: WGPUShaderModule,
    pub entryPoint: WGPUStringView,
    pub constantCount: usize,
    pub constants: *const WGPUConstantEntry,
    pub bufferCount: usize,
    pub buffers: *const WGPUVertexBufferLayout,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUVertexState"][::core::mem::size_of::<WGPUVertexState>() - 64usize];
    ["Alignment of WGPUVertexState"][::core::mem::align_of::<WGPUVertexState>() - 8usize];
    ["Offset of field: WGPUVertexState::nextInChain"]
        [::core::mem::offset_of!(WGPUVertexState, nextInChain) - 0usize];
    ["Offset of field: WGPUVertexState::module"]
        [::core::mem::offset_of!(WGPUVertexState, module) - 8usize];
    ["Offset of field: WGPUVertexState::entryPoint"]
        [::core::mem::offset_of!(WGPUVertexState, entryPoint) - 16usize];
    ["Offset of field: WGPUVertexState::constantCount"]
        [::core::mem::offset_of!(WGPUVertexState, constantCount) - 32usize];
    ["Offset of field: WGPUVertexState::constants"]
        [::core::mem::offset_of!(WGPUVertexState, constants) - 40usize];
    ["Offset of field: WGPUVertexState::bufferCount"]
        [::core::mem::offset_of!(WGPUVertexState, bufferCount) - 48usize];
    ["Offset of field: WGPUVertexState::buffers"]
        [::core::mem::offset_of!(WGPUVertexState, buffers) - 56usize];
};
impl Default for WGPUVertexState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPUFragmentState {
    pub nextInChain: *mut WGPUChainedStruct,
    pub module: WGPUShaderModule,
    pub entryPoint: WGPUStringView,
    pub constantCount: usize,
    pub constants: *const WGPUConstantEntry,
    pub targetCount: usize,
    pub targets: *const WGPUColorTargetState,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPUFragmentState"][::core::mem::size_of::<WGPUFragmentState>() - 64usize];
    ["Alignment of WGPUFragmentState"][::core::mem::align_of::<WGPUFragmentState>() - 8usize];
    ["Offset of field: WGPUFragmentState::nextInChain"]
        [::core::mem::offset_of!(WGPUFragmentState, nextInChain) - 0usize];
    ["Offset of field: WGPUFragmentState::module"]
        [::core::mem::offset_of!(WGPUFragmentState, module) - 8usize];
    ["Offset of field: WGPUFragmentState::entryPoint"]
        [::core::mem::offset_of!(WGPUFragmentState, entryPoint) - 16usize];
    ["Offset of field: WGPUFragmentState::constantCount"]
        [::core::mem::offset_of!(WGPUFragmentState, constantCount) - 32usize];
    ["Offset of field: WGPUFragmentState::constants"]
        [::core::mem::offset_of!(WGPUFragmentState, constants) - 40usize];
    ["Offset of field: WGPUFragmentState::targetCount"]
        [::core::mem::offset_of!(WGPUFragmentState, targetCount) - 48usize];
    ["Offset of field: WGPUFragmentState::targets"]
        [::core::mem::offset_of!(WGPUFragmentState, targets) - 56usize];
};
impl Default for WGPUFragmentState {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURenderPassDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub colorAttachmentCount: usize,
    pub colorAttachments: *const WGPURenderPassColorAttachment,
    pub depthStencilAttachment: *const WGPURenderPassDepthStencilAttachment,
    pub occlusionQuerySet: WGPUQuerySet,
    pub timestampWrites: *const WGPUPassTimestampWrites,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderPassDescriptor"]
        [::core::mem::size_of::<WGPURenderPassDescriptor>() - 64usize];
    ["Alignment of WGPURenderPassDescriptor"]
        [::core::mem::align_of::<WGPURenderPassDescriptor>() - 8usize];
    ["Offset of field: WGPURenderPassDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPURenderPassDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPURenderPassDescriptor::label"]
        [::core::mem::offset_of!(WGPURenderPassDescriptor, label) - 8usize];
    ["Offset of field: WGPURenderPassDescriptor::colorAttachmentCount"]
        [::core::mem::offset_of!(WGPURenderPassDescriptor, colorAttachmentCount) - 24usize];
    ["Offset of field: WGPURenderPassDescriptor::colorAttachments"]
        [::core::mem::offset_of!(WGPURenderPassDescriptor, colorAttachments) - 32usize];
    ["Offset of field: WGPURenderPassDescriptor::depthStencilAttachment"]
        [::core::mem::offset_of!(WGPURenderPassDescriptor, depthStencilAttachment) - 40usize];
    ["Offset of field: WGPURenderPassDescriptor::occlusionQuerySet"]
        [::core::mem::offset_of!(WGPURenderPassDescriptor, occlusionQuerySet) - 48usize];
    ["Offset of field: WGPURenderPassDescriptor::timestampWrites"]
        [::core::mem::offset_of!(WGPURenderPassDescriptor, timestampWrites) - 56usize];
};
impl Default for WGPURenderPassDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct WGPURenderPipelineDescriptor {
    pub nextInChain: *mut WGPUChainedStruct,
    pub label: WGPUStringView,
    pub layout: WGPUPipelineLayout,
    pub vertex: WGPUVertexState,
    pub primitive: WGPUPrimitiveState,
    pub depthStencil: *const WGPUDepthStencilState,
    pub multisample: WGPUMultisampleState,
    pub fragment: *const WGPUFragmentState,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of WGPURenderPipelineDescriptor"]
        [::core::mem::size_of::<WGPURenderPipelineDescriptor>() - 168usize];
    ["Alignment of WGPURenderPipelineDescriptor"]
        [::core::mem::align_of::<WGPURenderPipelineDescriptor>() - 8usize];
    ["Offset of field: WGPURenderPipelineDescriptor::nextInChain"]
        [::core::mem::offset_of!(WGPURenderPipelineDescriptor, nextInChain) - 0usize];
    ["Offset of field: WGPURenderPipelineDescriptor::label"]
        [::core::mem::offset_of!(WGPURenderPipelineDescriptor, label) - 8usize];
    ["Offset of field: WGPURenderPipelineDescriptor::layout"]
        [::core::mem::offset_of!(WGPURenderPipelineDescriptor, layout) - 24usize];
    ["Offset of field: WGPURenderPipelineDescriptor::vertex"]
        [::core::mem::offset_of!(WGPURenderPipelineDescriptor, vertex) - 32usize];
    ["Offset of field: WGPURenderPipelineDescriptor::primitive"]
        [::core::mem::offset_of!(WGPURenderPipelineDescriptor, primitive) - 96usize];
    ["Offset of field: WGPURenderPipelineDescriptor::depthStencil"]
        [::core::mem::offset_of!(WGPURenderPipelineDescriptor, depthStencil) - 128usize];
    ["Offset of field: WGPURenderPipelineDescriptor::multisample"]
        [::core::mem::offset_of!(WGPURenderPipelineDescriptor, multisample) - 136usize];
    ["Offset of field: WGPURenderPipelineDescriptor::fragment"]
        [::core::mem::offset_of!(WGPURenderPipelineDescriptor, fragment) - 160usize];
};
impl Default for WGPURenderPipelineDescriptor {
    fn default() -> Self {
        let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type WGPURenderPassDescriptorMaxDrawCount = WGPURenderPassMaxDrawCount;
pub type WGPUShaderModuleSPIRVDescriptor = WGPUShaderSourceSPIRV;
pub type WGPUShaderModuleWGSLDescriptor = WGPUShaderSourceWGSL;
pub type WGPUSurfaceDescriptorFromAndroidNativeWindow = WGPUSurfaceSourceAndroidNativeWindow;
pub type WGPUSurfaceDescriptorFromMetalLayer = WGPUSurfaceSourceMetalLayer;
pub type WGPUSurfaceDescriptorFromWaylandSurface = WGPUSurfaceSourceWaylandSurface;
pub type WGPUSurfaceDescriptorFromWindowsHWND = WGPUSurfaceSourceWindowsHWND;
pub type WGPUSurfaceDescriptorFromXcbWindow = WGPUSurfaceSourceXCBWindow;
pub type WGPUSurfaceDescriptorFromXlibWindow = WGPUSurfaceSourceXlibWindow;
pub type WGPUProcAdapterInfoFreeMembers =
    ::core::option::Option<unsafe extern "C" fn(value: WGPUAdapterInfo)>;
pub type WGPUProcAdapterPropertiesMemoryHeapsFreeMembers =
    ::core::option::Option<unsafe extern "C" fn(value: WGPUAdapterPropertiesMemoryHeaps)>;
pub type WGPUProcAdapterPropertiesSubgroupMatrixConfigsFreeMembers =
    ::core::option::Option<unsafe extern "C" fn(value: WGPUAdapterPropertiesSubgroupMatrixConfigs)>;
pub type WGPUProcCreateInstance = ::core::option::Option<
    unsafe extern "C" fn(descriptor: *const WGPUInstanceDescriptor) -> WGPUInstance,
>;
pub type WGPUProcDawnDrmFormatCapabilitiesFreeMembers =
    ::core::option::Option<unsafe extern "C" fn(value: WGPUDawnDrmFormatCapabilities)>;
pub type WGPUProcGetInstanceCapabilities = ::core::option::Option<
    unsafe extern "C" fn(capabilities: *mut WGPUInstanceCapabilities) -> WGPUStatus,
>;
pub type WGPUProcGetProcAddress =
    ::core::option::Option<unsafe extern "C" fn(procName: WGPUStringView) -> WGPUProc>;
pub type WGPUProcSharedBufferMemoryEndAccessStateFreeMembers =
    ::core::option::Option<unsafe extern "C" fn(value: WGPUSharedBufferMemoryEndAccessState)>;
pub type WGPUProcSharedTextureMemoryEndAccessStateFreeMembers =
    ::core::option::Option<unsafe extern "C" fn(value: WGPUSharedTextureMemoryEndAccessState)>;
pub type WGPUProcSupportedFeaturesFreeMembers =
    ::core::option::Option<unsafe extern "C" fn(value: WGPUSupportedFeatures)>;
pub type WGPUProcSupportedWGSLLanguageFeaturesFreeMembers =
    ::core::option::Option<unsafe extern "C" fn(value: WGPUSupportedWGSLLanguageFeatures)>;
pub type WGPUProcSurfaceCapabilitiesFreeMembers =
    ::core::option::Option<unsafe extern "C" fn(value: WGPUSurfaceCapabilities)>;
pub type WGPUProcAdapterCreateDevice = ::core::option::Option<
    unsafe extern "C" fn(
        adapter: WGPUAdapter,
        descriptor: *const WGPUDeviceDescriptor,
    ) -> WGPUDevice,
>;
pub type WGPUProcAdapterGetFeatures = ::core::option::Option<
    unsafe extern "C" fn(adapter: WGPUAdapter, features: *mut WGPUSupportedFeatures),
>;
pub type WGPUProcAdapterGetFormatCapabilities = ::core::option::Option<
    unsafe extern "C" fn(
        adapter: WGPUAdapter,
        format: WGPUTextureFormat,
        capabilities: *mut WGPUDawnFormatCapabilities,
    ) -> WGPUStatus,
>;
pub type WGPUProcAdapterGetInfo = ::core::option::Option<
    unsafe extern "C" fn(adapter: WGPUAdapter, info: *mut WGPUAdapterInfo) -> WGPUStatus,
>;
pub type WGPUProcAdapterGetInstance =
    ::core::option::Option<unsafe extern "C" fn(adapter: WGPUAdapter) -> WGPUInstance>;
pub type WGPUProcAdapterGetLimits = ::core::option::Option<
    unsafe extern "C" fn(adapter: WGPUAdapter, limits: *mut WGPULimits) -> WGPUStatus,
>;
pub type WGPUProcAdapterHasFeature = ::core::option::Option<
    unsafe extern "C" fn(adapter: WGPUAdapter, feature: WGPUFeatureName) -> WGPUBool,
>;
pub type WGPUProcAdapterRequestDevice = ::core::option::Option<
    unsafe extern "C" fn(
        adapter: WGPUAdapter,
        options: *const WGPUDeviceDescriptor,
        callbackInfo: WGPURequestDeviceCallbackInfo,
    ) -> WGPUFuture,
>;
pub type WGPUProcAdapterAddRef = ::core::option::Option<unsafe extern "C" fn(adapter: WGPUAdapter)>;
pub type WGPUProcAdapterRelease =
    ::core::option::Option<unsafe extern "C" fn(adapter: WGPUAdapter)>;
pub type WGPUProcBindGroupSetLabel =
    ::core::option::Option<unsafe extern "C" fn(bindGroup: WGPUBindGroup, label: WGPUStringView)>;
pub type WGPUProcBindGroupAddRef =
    ::core::option::Option<unsafe extern "C" fn(bindGroup: WGPUBindGroup)>;
pub type WGPUProcBindGroupRelease =
    ::core::option::Option<unsafe extern "C" fn(bindGroup: WGPUBindGroup)>;
pub type WGPUProcBindGroupLayoutSetLabel = ::core::option::Option<
    unsafe extern "C" fn(bindGroupLayout: WGPUBindGroupLayout, label: WGPUStringView),
>;
pub type WGPUProcBindGroupLayoutAddRef =
    ::core::option::Option<unsafe extern "C" fn(bindGroupLayout: WGPUBindGroupLayout)>;
pub type WGPUProcBindGroupLayoutRelease =
    ::core::option::Option<unsafe extern "C" fn(bindGroupLayout: WGPUBindGroupLayout)>;
pub type WGPUProcBufferDestroy = ::core::option::Option<unsafe extern "C" fn(buffer: WGPUBuffer)>;
pub type WGPUProcBufferGetConstMappedRange = ::core::option::Option<
    unsafe extern "C" fn(
        buffer: WGPUBuffer,
        offset: usize,
        size: usize,
    ) -> *const ::core::ffi::c_void,
>;
pub type WGPUProcBufferGetMappedRange = ::core::option::Option<
    unsafe extern "C" fn(
        buffer: WGPUBuffer,
        offset: usize,
        size: usize,
    ) -> *mut ::core::ffi::c_void,
>;
pub type WGPUProcBufferGetMapState =
    ::core::option::Option<unsafe extern "C" fn(buffer: WGPUBuffer) -> WGPUBufferMapState>;
pub type WGPUProcBufferGetSize =
    ::core::option::Option<unsafe extern "C" fn(buffer: WGPUBuffer) -> u64>;
pub type WGPUProcBufferGetUsage =
    ::core::option::Option<unsafe extern "C" fn(buffer: WGPUBuffer) -> WGPUBufferUsage>;
pub type WGPUProcBufferMapAsync = ::core::option::Option<
    unsafe extern "C" fn(
        buffer: WGPUBuffer,
        mode: WGPUMapMode,
        offset: usize,
        size: usize,
        callbackInfo: WGPUBufferMapCallbackInfo,
    ) -> WGPUFuture,
>;
pub type WGPUProcBufferReadMappedRange = ::core::option::Option<
    unsafe extern "C" fn(
        buffer: WGPUBuffer,
        offset: usize,
        data: *mut ::core::ffi::c_void,
        size: usize,
    ) -> WGPUStatus,
>;
pub type WGPUProcBufferSetLabel =
    ::core::option::Option<unsafe extern "C" fn(buffer: WGPUBuffer, label: WGPUStringView)>;
pub type WGPUProcBufferUnmap = ::core::option::Option<unsafe extern "C" fn(buffer: WGPUBuffer)>;
pub type WGPUProcBufferWriteMappedRange = ::core::option::Option<
    unsafe extern "C" fn(
        buffer: WGPUBuffer,
        offset: usize,
        data: *const ::core::ffi::c_void,
        size: usize,
    ) -> WGPUStatus,
>;
pub type WGPUProcBufferAddRef = ::core::option::Option<unsafe extern "C" fn(buffer: WGPUBuffer)>;
pub type WGPUProcBufferRelease = ::core::option::Option<unsafe extern "C" fn(buffer: WGPUBuffer)>;
pub type WGPUProcCommandBufferSetLabel = ::core::option::Option<
    unsafe extern "C" fn(commandBuffer: WGPUCommandBuffer, label: WGPUStringView),
>;
pub type WGPUProcCommandBufferAddRef =
    ::core::option::Option<unsafe extern "C" fn(commandBuffer: WGPUCommandBuffer)>;
pub type WGPUProcCommandBufferRelease =
    ::core::option::Option<unsafe extern "C" fn(commandBuffer: WGPUCommandBuffer)>;
pub type WGPUProcCommandEncoderBeginComputePass = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        descriptor: *const WGPUComputePassDescriptor,
    ) -> WGPUComputePassEncoder,
>;
pub type WGPUProcCommandEncoderBeginRenderPass = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        descriptor: *const WGPURenderPassDescriptor,
    ) -> WGPURenderPassEncoder,
>;
pub type WGPUProcCommandEncoderClearBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        buffer: WGPUBuffer,
        offset: u64,
        size: u64,
    ),
>;
pub type WGPUProcCommandEncoderCopyBufferToBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        source: WGPUBuffer,
        sourceOffset: u64,
        destination: WGPUBuffer,
        destinationOffset: u64,
        size: u64,
    ),
>;
pub type WGPUProcCommandEncoderCopyBufferToTexture = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        source: *const WGPUTexelCopyBufferInfo,
        destination: *const WGPUTexelCopyTextureInfo,
        copySize: *const WGPUExtent3D,
    ),
>;
pub type WGPUProcCommandEncoderCopyTextureToBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        source: *const WGPUTexelCopyTextureInfo,
        destination: *const WGPUTexelCopyBufferInfo,
        copySize: *const WGPUExtent3D,
    ),
>;
pub type WGPUProcCommandEncoderCopyTextureToTexture = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        source: *const WGPUTexelCopyTextureInfo,
        destination: *const WGPUTexelCopyTextureInfo,
        copySize: *const WGPUExtent3D,
    ),
>;
pub type WGPUProcCommandEncoderFinish = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        descriptor: *const WGPUCommandBufferDescriptor,
    ) -> WGPUCommandBuffer,
>;
pub type WGPUProcCommandEncoderInjectValidationError = ::core::option::Option<
    unsafe extern "C" fn(commandEncoder: WGPUCommandEncoder, message: WGPUStringView),
>;
pub type WGPUProcCommandEncoderInsertDebugMarker = ::core::option::Option<
    unsafe extern "C" fn(commandEncoder: WGPUCommandEncoder, markerLabel: WGPUStringView),
>;
pub type WGPUProcCommandEncoderPopDebugGroup =
    ::core::option::Option<unsafe extern "C" fn(commandEncoder: WGPUCommandEncoder)>;
pub type WGPUProcCommandEncoderPushDebugGroup = ::core::option::Option<
    unsafe extern "C" fn(commandEncoder: WGPUCommandEncoder, groupLabel: WGPUStringView),
>;
pub type WGPUProcCommandEncoderResolveQuerySet = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        querySet: WGPUQuerySet,
        firstQuery: u32,
        queryCount: u32,
        destination: WGPUBuffer,
        destinationOffset: u64,
    ),
>;
pub type WGPUProcCommandEncoderSetLabel = ::core::option::Option<
    unsafe extern "C" fn(commandEncoder: WGPUCommandEncoder, label: WGPUStringView),
>;
pub type WGPUProcCommandEncoderWriteBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        buffer: WGPUBuffer,
        bufferOffset: u64,
        data: *const u8,
        size: u64,
    ),
>;
pub type WGPUProcCommandEncoderWriteTimestamp = ::core::option::Option<
    unsafe extern "C" fn(
        commandEncoder: WGPUCommandEncoder,
        querySet: WGPUQuerySet,
        queryIndex: u32,
    ),
>;
pub type WGPUProcCommandEncoderAddRef =
    ::core::option::Option<unsafe extern "C" fn(commandEncoder: WGPUCommandEncoder)>;
pub type WGPUProcCommandEncoderRelease =
    ::core::option::Option<unsafe extern "C" fn(commandEncoder: WGPUCommandEncoder)>;
pub type WGPUProcComputePassEncoderDispatchWorkgroups = ::core::option::Option<
    unsafe extern "C" fn(
        computePassEncoder: WGPUComputePassEncoder,
        workgroupCountX: u32,
        workgroupCountY: u32,
        workgroupCountZ: u32,
    ),
>;
pub type WGPUProcComputePassEncoderDispatchWorkgroupsIndirect = ::core::option::Option<
    unsafe extern "C" fn(
        computePassEncoder: WGPUComputePassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    ),
>;
pub type WGPUProcComputePassEncoderEnd =
    ::core::option::Option<unsafe extern "C" fn(computePassEncoder: WGPUComputePassEncoder)>;
pub type WGPUProcComputePassEncoderInsertDebugMarker = ::core::option::Option<
    unsafe extern "C" fn(computePassEncoder: WGPUComputePassEncoder, markerLabel: WGPUStringView),
>;
pub type WGPUProcComputePassEncoderPopDebugGroup =
    ::core::option::Option<unsafe extern "C" fn(computePassEncoder: WGPUComputePassEncoder)>;
pub type WGPUProcComputePassEncoderPushDebugGroup = ::core::option::Option<
    unsafe extern "C" fn(computePassEncoder: WGPUComputePassEncoder, groupLabel: WGPUStringView),
>;
pub type WGPUProcComputePassEncoderSetBindGroup = ::core::option::Option<
    unsafe extern "C" fn(
        computePassEncoder: WGPUComputePassEncoder,
        groupIndex: u32,
        group: WGPUBindGroup,
        dynamicOffsetCount: usize,
        dynamicOffsets: *const u32,
    ),
>;
pub type WGPUProcComputePassEncoderSetImmediateData = ::core::option::Option<
    unsafe extern "C" fn(
        computePassEncoder: WGPUComputePassEncoder,
        offset: u32,
        data: *const ::core::ffi::c_void,
        size: usize,
    ),
>;
pub type WGPUProcComputePassEncoderSetLabel = ::core::option::Option<
    unsafe extern "C" fn(computePassEncoder: WGPUComputePassEncoder, label: WGPUStringView),
>;
pub type WGPUProcComputePassEncoderSetPipeline = ::core::option::Option<
    unsafe extern "C" fn(computePassEncoder: WGPUComputePassEncoder, pipeline: WGPUComputePipeline),
>;
pub type WGPUProcComputePassEncoderWriteTimestamp = ::core::option::Option<
    unsafe extern "C" fn(
        computePassEncoder: WGPUComputePassEncoder,
        querySet: WGPUQuerySet,
        queryIndex: u32,
    ),
>;
pub type WGPUProcComputePassEncoderAddRef =
    ::core::option::Option<unsafe extern "C" fn(computePassEncoder: WGPUComputePassEncoder)>;
pub type WGPUProcComputePassEncoderRelease =
    ::core::option::Option<unsafe extern "C" fn(computePassEncoder: WGPUComputePassEncoder)>;
pub type WGPUProcComputePipelineGetBindGroupLayout = ::core::option::Option<
    unsafe extern "C" fn(
        computePipeline: WGPUComputePipeline,
        groupIndex: u32,
    ) -> WGPUBindGroupLayout,
>;
pub type WGPUProcComputePipelineSetLabel = ::core::option::Option<
    unsafe extern "C" fn(computePipeline: WGPUComputePipeline, label: WGPUStringView),
>;
pub type WGPUProcComputePipelineAddRef =
    ::core::option::Option<unsafe extern "C" fn(computePipeline: WGPUComputePipeline)>;
pub type WGPUProcComputePipelineRelease =
    ::core::option::Option<unsafe extern "C" fn(computePipeline: WGPUComputePipeline)>;
pub type WGPUProcDeviceCreateBindGroup = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUBindGroupDescriptor,
    ) -> WGPUBindGroup,
>;
pub type WGPUProcDeviceCreateBindGroupLayout = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUBindGroupLayoutDescriptor,
    ) -> WGPUBindGroupLayout,
>;
pub type WGPUProcDeviceCreateBuffer = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, descriptor: *const WGPUBufferDescriptor) -> WGPUBuffer,
>;
pub type WGPUProcDeviceCreateCommandEncoder = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUCommandEncoderDescriptor,
    ) -> WGPUCommandEncoder,
>;
pub type WGPUProcDeviceCreateComputePipeline = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUComputePipelineDescriptor,
    ) -> WGPUComputePipeline,
>;
pub type WGPUProcDeviceCreateComputePipelineAsync = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUComputePipelineDescriptor,
        callbackInfo: WGPUCreateComputePipelineAsyncCallbackInfo,
    ) -> WGPUFuture,
>;
pub type WGPUProcDeviceCreateErrorBuffer = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, descriptor: *const WGPUBufferDescriptor) -> WGPUBuffer,
>;
pub type WGPUProcDeviceCreateErrorExternalTexture =
    ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice) -> WGPUExternalTexture>;
pub type WGPUProcDeviceCreateErrorShaderModule = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUShaderModuleDescriptor,
        errorMessage: WGPUStringView,
    ) -> WGPUShaderModule,
>;
pub type WGPUProcDeviceCreateErrorTexture = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUTextureDescriptor,
    ) -> WGPUTexture,
>;
pub type WGPUProcDeviceCreateExternalTexture = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        externalTextureDescriptor: *const WGPUExternalTextureDescriptor,
    ) -> WGPUExternalTexture,
>;
pub type WGPUProcDeviceCreatePipelineLayout = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUPipelineLayoutDescriptor,
    ) -> WGPUPipelineLayout,
>;
pub type WGPUProcDeviceCreateQuerySet = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUQuerySetDescriptor,
    ) -> WGPUQuerySet,
>;
pub type WGPUProcDeviceCreateRenderBundleEncoder = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPURenderBundleEncoderDescriptor,
    ) -> WGPURenderBundleEncoder,
>;
pub type WGPUProcDeviceCreateRenderPipeline = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPURenderPipelineDescriptor,
    ) -> WGPURenderPipeline,
>;
pub type WGPUProcDeviceCreateRenderPipelineAsync = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPURenderPipelineDescriptor,
        callbackInfo: WGPUCreateRenderPipelineAsyncCallbackInfo,
    ) -> WGPUFuture,
>;
pub type WGPUProcDeviceCreateSampler = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUSamplerDescriptor,
    ) -> WGPUSampler,
>;
pub type WGPUProcDeviceCreateShaderModule = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUShaderModuleDescriptor,
    ) -> WGPUShaderModule,
>;
pub type WGPUProcDeviceCreateTexture = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUTextureDescriptor,
    ) -> WGPUTexture,
>;
pub type WGPUProcDeviceDestroy = ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice)>;
pub type WGPUProcDeviceForceLoss = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, type_: WGPUDeviceLostReason, message: WGPUStringView),
>;
pub type WGPUProcDeviceGetAdapter =
    ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice) -> WGPUAdapter>;
pub type WGPUProcDeviceGetAdapterInfo = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, adapterInfo: *mut WGPUAdapterInfo) -> WGPUStatus,
>;
pub type WGPUProcDeviceGetAHardwareBufferProperties = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        handle: *mut ::core::ffi::c_void,
        properties: *mut WGPUAHardwareBufferProperties,
    ) -> WGPUStatus,
>;
pub type WGPUProcDeviceGetFeatures = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, features: *mut WGPUSupportedFeatures),
>;
pub type WGPUProcDeviceGetLimits = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, limits: *mut WGPULimits) -> WGPUStatus,
>;
pub type WGPUProcDeviceGetLostFuture =
    ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice) -> WGPUFuture>;
pub type WGPUProcDeviceGetQueue =
    ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice) -> WGPUQueue>;
pub type WGPUProcDeviceHasFeature = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, feature: WGPUFeatureName) -> WGPUBool,
>;
pub type WGPUProcDeviceImportSharedBufferMemory = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUSharedBufferMemoryDescriptor,
    ) -> WGPUSharedBufferMemory,
>;
pub type WGPUProcDeviceImportSharedFence = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUSharedFenceDescriptor,
    ) -> WGPUSharedFence,
>;
pub type WGPUProcDeviceImportSharedTextureMemory = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        descriptor: *const WGPUSharedTextureMemoryDescriptor,
    ) -> WGPUSharedTextureMemory,
>;
pub type WGPUProcDeviceInjectError = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, type_: WGPUErrorType, message: WGPUStringView),
>;
pub type WGPUProcDevicePopErrorScope = ::core::option::Option<
    unsafe extern "C" fn(
        device: WGPUDevice,
        callbackInfo: WGPUPopErrorScopeCallbackInfo,
    ) -> WGPUFuture,
>;
pub type WGPUProcDevicePushErrorScope =
    ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice, filter: WGPUErrorFilter)>;
pub type WGPUProcDeviceSetLabel =
    ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice, label: WGPUStringView)>;
pub type WGPUProcDeviceSetLoggingCallback = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, callbackInfo: WGPULoggingCallbackInfo),
>;
pub type WGPUProcDeviceTick = ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice)>;
pub type WGPUProcDeviceValidateTextureDescriptor = ::core::option::Option<
    unsafe extern "C" fn(device: WGPUDevice, descriptor: *const WGPUTextureDescriptor),
>;
pub type WGPUProcDeviceAddRef = ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice)>;
pub type WGPUProcDeviceRelease = ::core::option::Option<unsafe extern "C" fn(device: WGPUDevice)>;
pub type WGPUProcExternalTextureDestroy =
    ::core::option::Option<unsafe extern "C" fn(externalTexture: WGPUExternalTexture)>;
pub type WGPUProcExternalTextureExpire =
    ::core::option::Option<unsafe extern "C" fn(externalTexture: WGPUExternalTexture)>;
pub type WGPUProcExternalTextureRefresh =
    ::core::option::Option<unsafe extern "C" fn(externalTexture: WGPUExternalTexture)>;
pub type WGPUProcExternalTextureSetLabel = ::core::option::Option<
    unsafe extern "C" fn(externalTexture: WGPUExternalTexture, label: WGPUStringView),
>;
pub type WGPUProcExternalTextureAddRef =
    ::core::option::Option<unsafe extern "C" fn(externalTexture: WGPUExternalTexture)>;
pub type WGPUProcExternalTextureRelease =
    ::core::option::Option<unsafe extern "C" fn(externalTexture: WGPUExternalTexture)>;
pub type WGPUProcInstanceCreateSurface = ::core::option::Option<
    unsafe extern "C" fn(
        instance: WGPUInstance,
        descriptor: *const WGPUSurfaceDescriptor,
    ) -> WGPUSurface,
>;
pub type WGPUProcInstanceGetWGSLLanguageFeatures = ::core::option::Option<
    unsafe extern "C" fn(
        instance: WGPUInstance,
        features: *mut WGPUSupportedWGSLLanguageFeatures,
    ) -> WGPUStatus,
>;
pub type WGPUProcInstanceHasWGSLLanguageFeature = ::core::option::Option<
    unsafe extern "C" fn(instance: WGPUInstance, feature: WGPUWGSLLanguageFeatureName) -> WGPUBool,
>;
pub type WGPUProcInstanceProcessEvents =
    ::core::option::Option<unsafe extern "C" fn(instance: WGPUInstance)>;
pub type WGPUProcInstanceRequestAdapter = ::core::option::Option<
    unsafe extern "C" fn(
        instance: WGPUInstance,
        options: *const WGPURequestAdapterOptions,
        callbackInfo: WGPURequestAdapterCallbackInfo,
    ) -> WGPUFuture,
>;
pub type WGPUProcInstanceWaitAny = ::core::option::Option<
    unsafe extern "C" fn(
        instance: WGPUInstance,
        futureCount: usize,
        futures: *mut WGPUFutureWaitInfo,
        timeoutNS: u64,
    ) -> WGPUWaitStatus,
>;
pub type WGPUProcInstanceAddRef =
    ::core::option::Option<unsafe extern "C" fn(instance: WGPUInstance)>;
pub type WGPUProcInstanceRelease =
    ::core::option::Option<unsafe extern "C" fn(instance: WGPUInstance)>;
pub type WGPUProcPipelineLayoutSetLabel = ::core::option::Option<
    unsafe extern "C" fn(pipelineLayout: WGPUPipelineLayout, label: WGPUStringView),
>;
pub type WGPUProcPipelineLayoutAddRef =
    ::core::option::Option<unsafe extern "C" fn(pipelineLayout: WGPUPipelineLayout)>;
pub type WGPUProcPipelineLayoutRelease =
    ::core::option::Option<unsafe extern "C" fn(pipelineLayout: WGPUPipelineLayout)>;
pub type WGPUProcQuerySetDestroy =
    ::core::option::Option<unsafe extern "C" fn(querySet: WGPUQuerySet)>;
pub type WGPUProcQuerySetGetCount =
    ::core::option::Option<unsafe extern "C" fn(querySet: WGPUQuerySet) -> u32>;
pub type WGPUProcQuerySetGetType =
    ::core::option::Option<unsafe extern "C" fn(querySet: WGPUQuerySet) -> WGPUQueryType>;
pub type WGPUProcQuerySetSetLabel =
    ::core::option::Option<unsafe extern "C" fn(querySet: WGPUQuerySet, label: WGPUStringView)>;
pub type WGPUProcQuerySetAddRef =
    ::core::option::Option<unsafe extern "C" fn(querySet: WGPUQuerySet)>;
pub type WGPUProcQuerySetRelease =
    ::core::option::Option<unsafe extern "C" fn(querySet: WGPUQuerySet)>;
pub type WGPUProcQueueCopyExternalTextureForBrowser = ::core::option::Option<
    unsafe extern "C" fn(
        queue: WGPUQueue,
        source: *const WGPUImageCopyExternalTexture,
        destination: *const WGPUTexelCopyTextureInfo,
        copySize: *const WGPUExtent3D,
        options: *const WGPUCopyTextureForBrowserOptions,
    ),
>;
pub type WGPUProcQueueCopyTextureForBrowser = ::core::option::Option<
    unsafe extern "C" fn(
        queue: WGPUQueue,
        source: *const WGPUTexelCopyTextureInfo,
        destination: *const WGPUTexelCopyTextureInfo,
        copySize: *const WGPUExtent3D,
        options: *const WGPUCopyTextureForBrowserOptions,
    ),
>;
pub type WGPUProcQueueOnSubmittedWorkDone = ::core::option::Option<
    unsafe extern "C" fn(
        queue: WGPUQueue,
        callbackInfo: WGPUQueueWorkDoneCallbackInfo,
    ) -> WGPUFuture,
>;
pub type WGPUProcQueueSetLabel =
    ::core::option::Option<unsafe extern "C" fn(queue: WGPUQueue, label: WGPUStringView)>;
pub type WGPUProcQueueSubmit = ::core::option::Option<
    unsafe extern "C" fn(queue: WGPUQueue, commandCount: usize, commands: *const WGPUCommandBuffer),
>;
pub type WGPUProcQueueWriteBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        queue: WGPUQueue,
        buffer: WGPUBuffer,
        bufferOffset: u64,
        data: *const ::core::ffi::c_void,
        size: usize,
    ),
>;
pub type WGPUProcQueueWriteTexture = ::core::option::Option<
    unsafe extern "C" fn(
        queue: WGPUQueue,
        destination: *const WGPUTexelCopyTextureInfo,
        data: *const ::core::ffi::c_void,
        dataSize: usize,
        dataLayout: *const WGPUTexelCopyBufferLayout,
        writeSize: *const WGPUExtent3D,
    ),
>;
pub type WGPUProcQueueAddRef = ::core::option::Option<unsafe extern "C" fn(queue: WGPUQueue)>;
pub type WGPUProcQueueRelease = ::core::option::Option<unsafe extern "C" fn(queue: WGPUQueue)>;
pub type WGPUProcRenderBundleSetLabel = ::core::option::Option<
    unsafe extern "C" fn(renderBundle: WGPURenderBundle, label: WGPUStringView),
>;
pub type WGPUProcRenderBundleAddRef =
    ::core::option::Option<unsafe extern "C" fn(renderBundle: WGPURenderBundle)>;
pub type WGPUProcRenderBundleRelease =
    ::core::option::Option<unsafe extern "C" fn(renderBundle: WGPURenderBundle)>;
pub type WGPUProcRenderBundleEncoderDraw = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        vertexCount: u32,
        instanceCount: u32,
        firstVertex: u32,
        firstInstance: u32,
    ),
>;
pub type WGPUProcRenderBundleEncoderDrawIndexed = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        indexCount: u32,
        instanceCount: u32,
        firstIndex: u32,
        baseVertex: i32,
        firstInstance: u32,
    ),
>;
pub type WGPUProcRenderBundleEncoderDrawIndexedIndirect = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    ),
>;
pub type WGPUProcRenderBundleEncoderDrawIndirect = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    ),
>;
pub type WGPUProcRenderBundleEncoderFinish = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        descriptor: *const WGPURenderBundleDescriptor,
    ) -> WGPURenderBundle,
>;
pub type WGPUProcRenderBundleEncoderInsertDebugMarker = ::core::option::Option<
    unsafe extern "C" fn(renderBundleEncoder: WGPURenderBundleEncoder, markerLabel: WGPUStringView),
>;
pub type WGPUProcRenderBundleEncoderPopDebugGroup =
    ::core::option::Option<unsafe extern "C" fn(renderBundleEncoder: WGPURenderBundleEncoder)>;
pub type WGPUProcRenderBundleEncoderPushDebugGroup = ::core::option::Option<
    unsafe extern "C" fn(renderBundleEncoder: WGPURenderBundleEncoder, groupLabel: WGPUStringView),
>;
pub type WGPUProcRenderBundleEncoderSetBindGroup = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        groupIndex: u32,
        group: WGPUBindGroup,
        dynamicOffsetCount: usize,
        dynamicOffsets: *const u32,
    ),
>;
pub type WGPUProcRenderBundleEncoderSetImmediateData = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        offset: u32,
        data: *const ::core::ffi::c_void,
        size: usize,
    ),
>;
pub type WGPUProcRenderBundleEncoderSetIndexBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        buffer: WGPUBuffer,
        format: WGPUIndexFormat,
        offset: u64,
        size: u64,
    ),
>;
pub type WGPUProcRenderBundleEncoderSetLabel = ::core::option::Option<
    unsafe extern "C" fn(renderBundleEncoder: WGPURenderBundleEncoder, label: WGPUStringView),
>;
pub type WGPUProcRenderBundleEncoderSetPipeline = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        pipeline: WGPURenderPipeline,
    ),
>;
pub type WGPUProcRenderBundleEncoderSetVertexBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        renderBundleEncoder: WGPURenderBundleEncoder,
        slot: u32,
        buffer: WGPUBuffer,
        offset: u64,
        size: u64,
    ),
>;
pub type WGPUProcRenderBundleEncoderAddRef =
    ::core::option::Option<unsafe extern "C" fn(renderBundleEncoder: WGPURenderBundleEncoder)>;
pub type WGPUProcRenderBundleEncoderRelease =
    ::core::option::Option<unsafe extern "C" fn(renderBundleEncoder: WGPURenderBundleEncoder)>;
pub type WGPUProcRenderPassEncoderBeginOcclusionQuery = ::core::option::Option<
    unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder, queryIndex: u32),
>;
pub type WGPUProcRenderPassEncoderDraw = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        vertexCount: u32,
        instanceCount: u32,
        firstVertex: u32,
        firstInstance: u32,
    ),
>;
pub type WGPUProcRenderPassEncoderDrawIndexed = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        indexCount: u32,
        instanceCount: u32,
        firstIndex: u32,
        baseVertex: i32,
        firstInstance: u32,
    ),
>;
pub type WGPUProcRenderPassEncoderDrawIndexedIndirect = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    ),
>;
pub type WGPUProcRenderPassEncoderDrawIndirect = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    ),
>;
pub type WGPUProcRenderPassEncoderEnd =
    ::core::option::Option<unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder)>;
pub type WGPUProcRenderPassEncoderEndOcclusionQuery =
    ::core::option::Option<unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder)>;
pub type WGPUProcRenderPassEncoderExecuteBundles = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        bundleCount: usize,
        bundles: *const WGPURenderBundle,
    ),
>;
pub type WGPUProcRenderPassEncoderInsertDebugMarker = ::core::option::Option<
    unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder, markerLabel: WGPUStringView),
>;
pub type WGPUProcRenderPassEncoderMultiDrawIndexedIndirect = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
        maxDrawCount: u32,
        drawCountBuffer: WGPUBuffer,
        drawCountBufferOffset: u64,
    ),
>;
pub type WGPUProcRenderPassEncoderMultiDrawIndirect = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
        maxDrawCount: u32,
        drawCountBuffer: WGPUBuffer,
        drawCountBufferOffset: u64,
    ),
>;
pub type WGPUProcRenderPassEncoderPixelLocalStorageBarrier =
    ::core::option::Option<unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder)>;
pub type WGPUProcRenderPassEncoderPopDebugGroup =
    ::core::option::Option<unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder)>;
pub type WGPUProcRenderPassEncoderPushDebugGroup = ::core::option::Option<
    unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder, groupLabel: WGPUStringView),
>;
pub type WGPUProcRenderPassEncoderSetBindGroup = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        groupIndex: u32,
        group: WGPUBindGroup,
        dynamicOffsetCount: usize,
        dynamicOffsets: *const u32,
    ),
>;
pub type WGPUProcRenderPassEncoderSetBlendConstant = ::core::option::Option<
    unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder, color: *const WGPUColor),
>;
pub type WGPUProcRenderPassEncoderSetImmediateData = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        offset: u32,
        data: *const ::core::ffi::c_void,
        size: usize,
    ),
>;
pub type WGPUProcRenderPassEncoderSetIndexBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        buffer: WGPUBuffer,
        format: WGPUIndexFormat,
        offset: u64,
        size: u64,
    ),
>;
pub type WGPUProcRenderPassEncoderSetLabel = ::core::option::Option<
    unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder, label: WGPUStringView),
>;
pub type WGPUProcRenderPassEncoderSetPipeline = ::core::option::Option<
    unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder, pipeline: WGPURenderPipeline),
>;
pub type WGPUProcRenderPassEncoderSetScissorRect = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        x: u32,
        y: u32,
        width: u32,
        height: u32,
    ),
>;
pub type WGPUProcRenderPassEncoderSetStencilReference = ::core::option::Option<
    unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder, reference: u32),
>;
pub type WGPUProcRenderPassEncoderSetVertexBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        slot: u32,
        buffer: WGPUBuffer,
        offset: u64,
        size: u64,
    ),
>;
pub type WGPUProcRenderPassEncoderSetViewport = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        x: f32,
        y: f32,
        width: f32,
        height: f32,
        minDepth: f32,
        maxDepth: f32,
    ),
>;
pub type WGPUProcRenderPassEncoderWriteTimestamp = ::core::option::Option<
    unsafe extern "C" fn(
        renderPassEncoder: WGPURenderPassEncoder,
        querySet: WGPUQuerySet,
        queryIndex: u32,
    ),
>;
pub type WGPUProcRenderPassEncoderAddRef =
    ::core::option::Option<unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder)>;
pub type WGPUProcRenderPassEncoderRelease =
    ::core::option::Option<unsafe extern "C" fn(renderPassEncoder: WGPURenderPassEncoder)>;
pub type WGPUProcRenderPipelineGetBindGroupLayout = ::core::option::Option<
    unsafe extern "C" fn(
        renderPipeline: WGPURenderPipeline,
        groupIndex: u32,
    ) -> WGPUBindGroupLayout,
>;
pub type WGPUProcRenderPipelineSetLabel = ::core::option::Option<
    unsafe extern "C" fn(renderPipeline: WGPURenderPipeline, label: WGPUStringView),
>;
pub type WGPUProcRenderPipelineAddRef =
    ::core::option::Option<unsafe extern "C" fn(renderPipeline: WGPURenderPipeline)>;
pub type WGPUProcRenderPipelineRelease =
    ::core::option::Option<unsafe extern "C" fn(renderPipeline: WGPURenderPipeline)>;
pub type WGPUProcSamplerSetLabel =
    ::core::option::Option<unsafe extern "C" fn(sampler: WGPUSampler, label: WGPUStringView)>;
pub type WGPUProcSamplerAddRef = ::core::option::Option<unsafe extern "C" fn(sampler: WGPUSampler)>;
pub type WGPUProcSamplerRelease =
    ::core::option::Option<unsafe extern "C" fn(sampler: WGPUSampler)>;
pub type WGPUProcShaderModuleGetCompilationInfo = ::core::option::Option<
    unsafe extern "C" fn(
        shaderModule: WGPUShaderModule,
        callbackInfo: WGPUCompilationInfoCallbackInfo,
    ) -> WGPUFuture,
>;
pub type WGPUProcShaderModuleSetLabel = ::core::option::Option<
    unsafe extern "C" fn(shaderModule: WGPUShaderModule, label: WGPUStringView),
>;
pub type WGPUProcShaderModuleAddRef =
    ::core::option::Option<unsafe extern "C" fn(shaderModule: WGPUShaderModule)>;
pub type WGPUProcShaderModuleRelease =
    ::core::option::Option<unsafe extern "C" fn(shaderModule: WGPUShaderModule)>;
pub type WGPUProcSharedBufferMemoryBeginAccess = ::core::option::Option<
    unsafe extern "C" fn(
        sharedBufferMemory: WGPUSharedBufferMemory,
        buffer: WGPUBuffer,
        descriptor: *const WGPUSharedBufferMemoryBeginAccessDescriptor,
    ) -> WGPUStatus,
>;
pub type WGPUProcSharedBufferMemoryCreateBuffer = ::core::option::Option<
    unsafe extern "C" fn(
        sharedBufferMemory: WGPUSharedBufferMemory,
        descriptor: *const WGPUBufferDescriptor,
    ) -> WGPUBuffer,
>;
pub type WGPUProcSharedBufferMemoryEndAccess = ::core::option::Option<
    unsafe extern "C" fn(
        sharedBufferMemory: WGPUSharedBufferMemory,
        buffer: WGPUBuffer,
        descriptor: *mut WGPUSharedBufferMemoryEndAccessState,
    ) -> WGPUStatus,
>;
pub type WGPUProcSharedBufferMemoryGetProperties = ::core::option::Option<
    unsafe extern "C" fn(
        sharedBufferMemory: WGPUSharedBufferMemory,
        properties: *mut WGPUSharedBufferMemoryProperties,
    ) -> WGPUStatus,
>;
pub type WGPUProcSharedBufferMemoryIsDeviceLost = ::core::option::Option<
    unsafe extern "C" fn(sharedBufferMemory: WGPUSharedBufferMemory) -> WGPUBool,
>;
pub type WGPUProcSharedBufferMemorySetLabel = ::core::option::Option<
    unsafe extern "C" fn(sharedBufferMemory: WGPUSharedBufferMemory, label: WGPUStringView),
>;
pub type WGPUProcSharedBufferMemoryAddRef =
    ::core::option::Option<unsafe extern "C" fn(sharedBufferMemory: WGPUSharedBufferMemory)>;
pub type WGPUProcSharedBufferMemoryRelease =
    ::core::option::Option<unsafe extern "C" fn(sharedBufferMemory: WGPUSharedBufferMemory)>;
pub type WGPUProcSharedFenceExportInfo = ::core::option::Option<
    unsafe extern "C" fn(sharedFence: WGPUSharedFence, info: *mut WGPUSharedFenceExportInfo),
>;
pub type WGPUProcSharedFenceAddRef =
    ::core::option::Option<unsafe extern "C" fn(sharedFence: WGPUSharedFence)>;
pub type WGPUProcSharedFenceRelease =
    ::core::option::Option<unsafe extern "C" fn(sharedFence: WGPUSharedFence)>;
pub type WGPUProcSharedTextureMemoryBeginAccess = ::core::option::Option<
    unsafe extern "C" fn(
        sharedTextureMemory: WGPUSharedTextureMemory,
        texture: WGPUTexture,
        descriptor: *const WGPUSharedTextureMemoryBeginAccessDescriptor,
    ) -> WGPUStatus,
>;
pub type WGPUProcSharedTextureMemoryCreateTexture = ::core::option::Option<
    unsafe extern "C" fn(
        sharedTextureMemory: WGPUSharedTextureMemory,
        descriptor: *const WGPUTextureDescriptor,
    ) -> WGPUTexture,
>;
pub type WGPUProcSharedTextureMemoryEndAccess = ::core::option::Option<
    unsafe extern "C" fn(
        sharedTextureMemory: WGPUSharedTextureMemory,
        texture: WGPUTexture,
        descriptor: *mut WGPUSharedTextureMemoryEndAccessState,
    ) -> WGPUStatus,
>;
pub type WGPUProcSharedTextureMemoryGetProperties = ::core::option::Option<
    unsafe extern "C" fn(
        sharedTextureMemory: WGPUSharedTextureMemory,
        properties: *mut WGPUSharedTextureMemoryProperties,
    ) -> WGPUStatus,
>;
pub type WGPUProcSharedTextureMemoryIsDeviceLost = ::core::option::Option<
    unsafe extern "C" fn(sharedTextureMemory: WGPUSharedTextureMemory) -> WGPUBool,
>;
pub type WGPUProcSharedTextureMemorySetLabel = ::core::option::Option<
    unsafe extern "C" fn(sharedTextureMemory: WGPUSharedTextureMemory, label: WGPUStringView),
>;
pub type WGPUProcSharedTextureMemoryAddRef =
    ::core::option::Option<unsafe extern "C" fn(sharedTextureMemory: WGPUSharedTextureMemory)>;
pub type WGPUProcSharedTextureMemoryRelease =
    ::core::option::Option<unsafe extern "C" fn(sharedTextureMemory: WGPUSharedTextureMemory)>;
pub type WGPUProcSurfaceConfigure = ::core::option::Option<
    unsafe extern "C" fn(surface: WGPUSurface, config: *const WGPUSurfaceConfiguration),
>;
pub type WGPUProcSurfaceGetCapabilities = ::core::option::Option<
    unsafe extern "C" fn(
        surface: WGPUSurface,
        adapter: WGPUAdapter,
        capabilities: *mut WGPUSurfaceCapabilities,
    ) -> WGPUStatus,
>;
pub type WGPUProcSurfaceGetCurrentTexture = ::core::option::Option<
    unsafe extern "C" fn(surface: WGPUSurface, surfaceTexture: *mut WGPUSurfaceTexture),
>;
pub type WGPUProcSurfacePresent =
    ::core::option::Option<unsafe extern "C" fn(surface: WGPUSurface)>;
pub type WGPUProcSurfaceSetLabel =
    ::core::option::Option<unsafe extern "C" fn(surface: WGPUSurface, label: WGPUStringView)>;
pub type WGPUProcSurfaceUnconfigure =
    ::core::option::Option<unsafe extern "C" fn(surface: WGPUSurface)>;
pub type WGPUProcSurfaceAddRef = ::core::option::Option<unsafe extern "C" fn(surface: WGPUSurface)>;
pub type WGPUProcSurfaceRelease =
    ::core::option::Option<unsafe extern "C" fn(surface: WGPUSurface)>;
pub type WGPUProcTextureCreateErrorView = ::core::option::Option<
    unsafe extern "C" fn(
        texture: WGPUTexture,
        descriptor: *const WGPUTextureViewDescriptor,
    ) -> WGPUTextureView,
>;
pub type WGPUProcTextureCreateView = ::core::option::Option<
    unsafe extern "C" fn(
        texture: WGPUTexture,
        descriptor: *const WGPUTextureViewDescriptor,
    ) -> WGPUTextureView,
>;
pub type WGPUProcTextureDestroy =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture)>;
pub type WGPUProcTextureGetDepthOrArrayLayers =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture) -> u32>;
pub type WGPUProcTextureGetDimension =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture) -> WGPUTextureDimension>;
pub type WGPUProcTextureGetFormat =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture) -> WGPUTextureFormat>;
pub type WGPUProcTextureGetHeight =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture) -> u32>;
pub type WGPUProcTextureGetMipLevelCount =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture) -> u32>;
pub type WGPUProcTextureGetSampleCount =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture) -> u32>;
pub type WGPUProcTextureGetUsage =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture) -> WGPUTextureUsage>;
pub type WGPUProcTextureGetWidth =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture) -> u32>;
pub type WGPUProcTextureSetLabel =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture, label: WGPUStringView)>;
pub type WGPUProcTextureAddRef = ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture)>;
pub type WGPUProcTextureRelease =
    ::core::option::Option<unsafe extern "C" fn(texture: WGPUTexture)>;
pub type WGPUProcTextureViewSetLabel = ::core::option::Option<
    unsafe extern "C" fn(textureView: WGPUTextureView, label: WGPUStringView),
>;
pub type WGPUProcTextureViewAddRef =
    ::core::option::Option<unsafe extern "C" fn(textureView: WGPUTextureView)>;
pub type WGPUProcTextureViewRelease =
    ::core::option::Option<unsafe extern "C" fn(textureView: WGPUTextureView)>;
unsafe extern "C" {
    pub fn wgpuAdapterInfoFreeMembers(value: WGPUAdapterInfo);
}
unsafe extern "C" {
    pub fn wgpuAdapterPropertiesMemoryHeapsFreeMembers(value: WGPUAdapterPropertiesMemoryHeaps);
}
unsafe extern "C" {
    pub fn wgpuAdapterPropertiesSubgroupMatrixConfigsFreeMembers(
        value: WGPUAdapterPropertiesSubgroupMatrixConfigs,
    );
}
unsafe extern "C" {
    pub fn wgpuCreateInstance(descriptor: *const WGPUInstanceDescriptor) -> WGPUInstance;
}
unsafe extern "C" {
    pub fn wgpuDawnDrmFormatCapabilitiesFreeMembers(value: WGPUDawnDrmFormatCapabilities);
}
unsafe extern "C" {
    pub fn wgpuGetInstanceCapabilities(capabilities: *mut WGPUInstanceCapabilities) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuGetProcAddress(procName: WGPUStringView) -> WGPUProc;
}
unsafe extern "C" {
    pub fn wgpuSharedBufferMemoryEndAccessStateFreeMembers(
        value: WGPUSharedBufferMemoryEndAccessState,
    );
}
unsafe extern "C" {
    pub fn wgpuSharedTextureMemoryEndAccessStateFreeMembers(
        value: WGPUSharedTextureMemoryEndAccessState,
    );
}
unsafe extern "C" {
    pub fn wgpuSupportedFeaturesFreeMembers(value: WGPUSupportedFeatures);
}
unsafe extern "C" {
    pub fn wgpuSupportedWGSLLanguageFeaturesFreeMembers(value: WGPUSupportedWGSLLanguageFeatures);
}
unsafe extern "C" {
    pub fn wgpuSurfaceCapabilitiesFreeMembers(value: WGPUSurfaceCapabilities);
}
unsafe extern "C" {
    pub fn wgpuAdapterCreateDevice(
        adapter: WGPUAdapter,
        descriptor: *const WGPUDeviceDescriptor,
    ) -> WGPUDevice;
}
unsafe extern "C" {
    pub fn wgpuAdapterGetFeatures(adapter: WGPUAdapter, features: *mut WGPUSupportedFeatures);
}
unsafe extern "C" {
    pub fn wgpuAdapterGetFormatCapabilities(
        adapter: WGPUAdapter,
        format: WGPUTextureFormat,
        capabilities: *mut WGPUDawnFormatCapabilities,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuAdapterGetInfo(adapter: WGPUAdapter, info: *mut WGPUAdapterInfo) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuAdapterGetInstance(adapter: WGPUAdapter) -> WGPUInstance;
}
unsafe extern "C" {
    pub fn wgpuAdapterGetLimits(adapter: WGPUAdapter, limits: *mut WGPULimits) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuAdapterHasFeature(adapter: WGPUAdapter, feature: WGPUFeatureName) -> WGPUBool;
}
unsafe extern "C" {
    pub fn wgpuAdapterRequestDevice(
        adapter: WGPUAdapter,
        options: *const WGPUDeviceDescriptor,
        callbackInfo: WGPURequestDeviceCallbackInfo,
    ) -> WGPUFuture;
}
unsafe extern "C" {
    pub fn wgpuAdapterAddRef(adapter: WGPUAdapter);
}
unsafe extern "C" {
    pub fn wgpuAdapterRelease(adapter: WGPUAdapter);
}
unsafe extern "C" {
    pub fn wgpuBindGroupSetLabel(bindGroup: WGPUBindGroup, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuBindGroupAddRef(bindGroup: WGPUBindGroup);
}
unsafe extern "C" {
    pub fn wgpuBindGroupRelease(bindGroup: WGPUBindGroup);
}
unsafe extern "C" {
    pub fn wgpuBindGroupLayoutSetLabel(bindGroupLayout: WGPUBindGroupLayout, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuBindGroupLayoutAddRef(bindGroupLayout: WGPUBindGroupLayout);
}
unsafe extern "C" {
    pub fn wgpuBindGroupLayoutRelease(bindGroupLayout: WGPUBindGroupLayout);
}
unsafe extern "C" {
    pub fn wgpuBufferDestroy(buffer: WGPUBuffer);
}
unsafe extern "C" {
    pub fn wgpuBufferGetConstMappedRange(
        buffer: WGPUBuffer,
        offset: usize,
        size: usize,
    ) -> *const ::core::ffi::c_void;
}
unsafe extern "C" {
    pub fn wgpuBufferGetMappedRange(
        buffer: WGPUBuffer,
        offset: usize,
        size: usize,
    ) -> *mut ::core::ffi::c_void;
}
unsafe extern "C" {
    pub fn wgpuBufferGetMapState(buffer: WGPUBuffer) -> WGPUBufferMapState;
}
unsafe extern "C" {
    pub fn wgpuBufferGetSize(buffer: WGPUBuffer) -> u64;
}
unsafe extern "C" {
    pub fn wgpuBufferGetUsage(buffer: WGPUBuffer) -> WGPUBufferUsage;
}
unsafe extern "C" {
    pub fn wgpuBufferMapAsync(
        buffer: WGPUBuffer,
        mode: WGPUMapMode,
        offset: usize,
        size: usize,
        callbackInfo: WGPUBufferMapCallbackInfo,
    ) -> WGPUFuture;
}
unsafe extern "C" {
    pub fn wgpuBufferReadMappedRange(
        buffer: WGPUBuffer,
        offset: usize,
        data: *mut ::core::ffi::c_void,
        size: usize,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuBufferSetLabel(buffer: WGPUBuffer, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuBufferUnmap(buffer: WGPUBuffer);
}
unsafe extern "C" {
    pub fn wgpuBufferWriteMappedRange(
        buffer: WGPUBuffer,
        offset: usize,
        data: *const ::core::ffi::c_void,
        size: usize,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuBufferAddRef(buffer: WGPUBuffer);
}
unsafe extern "C" {
    pub fn wgpuBufferRelease(buffer: WGPUBuffer);
}
unsafe extern "C" {
    pub fn wgpuCommandBufferSetLabel(commandBuffer: WGPUCommandBuffer, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuCommandBufferAddRef(commandBuffer: WGPUCommandBuffer);
}
unsafe extern "C" {
    pub fn wgpuCommandBufferRelease(commandBuffer: WGPUCommandBuffer);
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderBeginComputePass(
        commandEncoder: WGPUCommandEncoder,
        descriptor: *const WGPUComputePassDescriptor,
    ) -> WGPUComputePassEncoder;
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderBeginRenderPass(
        commandEncoder: WGPUCommandEncoder,
        descriptor: *const WGPURenderPassDescriptor,
    ) -> WGPURenderPassEncoder;
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderClearBuffer(
        commandEncoder: WGPUCommandEncoder,
        buffer: WGPUBuffer,
        offset: u64,
        size: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderCopyBufferToBuffer(
        commandEncoder: WGPUCommandEncoder,
        source: WGPUBuffer,
        sourceOffset: u64,
        destination: WGPUBuffer,
        destinationOffset: u64,
        size: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderCopyBufferToTexture(
        commandEncoder: WGPUCommandEncoder,
        source: *const WGPUTexelCopyBufferInfo,
        destination: *const WGPUTexelCopyTextureInfo,
        copySize: *const WGPUExtent3D,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderCopyTextureToBuffer(
        commandEncoder: WGPUCommandEncoder,
        source: *const WGPUTexelCopyTextureInfo,
        destination: *const WGPUTexelCopyBufferInfo,
        copySize: *const WGPUExtent3D,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderCopyTextureToTexture(
        commandEncoder: WGPUCommandEncoder,
        source: *const WGPUTexelCopyTextureInfo,
        destination: *const WGPUTexelCopyTextureInfo,
        copySize: *const WGPUExtent3D,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderFinish(
        commandEncoder: WGPUCommandEncoder,
        descriptor: *const WGPUCommandBufferDescriptor,
    ) -> WGPUCommandBuffer;
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderInjectValidationError(
        commandEncoder: WGPUCommandEncoder,
        message: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderInsertDebugMarker(
        commandEncoder: WGPUCommandEncoder,
        markerLabel: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderPopDebugGroup(commandEncoder: WGPUCommandEncoder);
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderPushDebugGroup(
        commandEncoder: WGPUCommandEncoder,
        groupLabel: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderResolveQuerySet(
        commandEncoder: WGPUCommandEncoder,
        querySet: WGPUQuerySet,
        firstQuery: u32,
        queryCount: u32,
        destination: WGPUBuffer,
        destinationOffset: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderSetLabel(commandEncoder: WGPUCommandEncoder, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderWriteBuffer(
        commandEncoder: WGPUCommandEncoder,
        buffer: WGPUBuffer,
        bufferOffset: u64,
        data: *const u8,
        size: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderWriteTimestamp(
        commandEncoder: WGPUCommandEncoder,
        querySet: WGPUQuerySet,
        queryIndex: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderAddRef(commandEncoder: WGPUCommandEncoder);
}
unsafe extern "C" {
    pub fn wgpuCommandEncoderRelease(commandEncoder: WGPUCommandEncoder);
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderDispatchWorkgroups(
        computePassEncoder: WGPUComputePassEncoder,
        workgroupCountX: u32,
        workgroupCountY: u32,
        workgroupCountZ: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderDispatchWorkgroupsIndirect(
        computePassEncoder: WGPUComputePassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderEnd(computePassEncoder: WGPUComputePassEncoder);
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderInsertDebugMarker(
        computePassEncoder: WGPUComputePassEncoder,
        markerLabel: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderPopDebugGroup(computePassEncoder: WGPUComputePassEncoder);
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderPushDebugGroup(
        computePassEncoder: WGPUComputePassEncoder,
        groupLabel: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderSetBindGroup(
        computePassEncoder: WGPUComputePassEncoder,
        groupIndex: u32,
        group: WGPUBindGroup,
        dynamicOffsetCount: usize,
        dynamicOffsets: *const u32,
    );
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderSetImmediateData(
        computePassEncoder: WGPUComputePassEncoder,
        offset: u32,
        data: *const ::core::ffi::c_void,
        size: usize,
    );
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderSetLabel(
        computePassEncoder: WGPUComputePassEncoder,
        label: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderSetPipeline(
        computePassEncoder: WGPUComputePassEncoder,
        pipeline: WGPUComputePipeline,
    );
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderWriteTimestamp(
        computePassEncoder: WGPUComputePassEncoder,
        querySet: WGPUQuerySet,
        queryIndex: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderAddRef(computePassEncoder: WGPUComputePassEncoder);
}
unsafe extern "C" {
    pub fn wgpuComputePassEncoderRelease(computePassEncoder: WGPUComputePassEncoder);
}
unsafe extern "C" {
    pub fn wgpuComputePipelineGetBindGroupLayout(
        computePipeline: WGPUComputePipeline,
        groupIndex: u32,
    ) -> WGPUBindGroupLayout;
}
unsafe extern "C" {
    pub fn wgpuComputePipelineSetLabel(computePipeline: WGPUComputePipeline, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuComputePipelineAddRef(computePipeline: WGPUComputePipeline);
}
unsafe extern "C" {
    pub fn wgpuComputePipelineRelease(computePipeline: WGPUComputePipeline);
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateBindGroup(
        device: WGPUDevice,
        descriptor: *const WGPUBindGroupDescriptor,
    ) -> WGPUBindGroup;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateBindGroupLayout(
        device: WGPUDevice,
        descriptor: *const WGPUBindGroupLayoutDescriptor,
    ) -> WGPUBindGroupLayout;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateBuffer(
        device: WGPUDevice,
        descriptor: *const WGPUBufferDescriptor,
    ) -> WGPUBuffer;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateCommandEncoder(
        device: WGPUDevice,
        descriptor: *const WGPUCommandEncoderDescriptor,
    ) -> WGPUCommandEncoder;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateComputePipeline(
        device: WGPUDevice,
        descriptor: *const WGPUComputePipelineDescriptor,
    ) -> WGPUComputePipeline;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateComputePipelineAsync(
        device: WGPUDevice,
        descriptor: *const WGPUComputePipelineDescriptor,
        callbackInfo: WGPUCreateComputePipelineAsyncCallbackInfo,
    ) -> WGPUFuture;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateErrorBuffer(
        device: WGPUDevice,
        descriptor: *const WGPUBufferDescriptor,
    ) -> WGPUBuffer;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateErrorExternalTexture(device: WGPUDevice) -> WGPUExternalTexture;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateErrorShaderModule(
        device: WGPUDevice,
        descriptor: *const WGPUShaderModuleDescriptor,
        errorMessage: WGPUStringView,
    ) -> WGPUShaderModule;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateErrorTexture(
        device: WGPUDevice,
        descriptor: *const WGPUTextureDescriptor,
    ) -> WGPUTexture;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateExternalTexture(
        device: WGPUDevice,
        externalTextureDescriptor: *const WGPUExternalTextureDescriptor,
    ) -> WGPUExternalTexture;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreatePipelineLayout(
        device: WGPUDevice,
        descriptor: *const WGPUPipelineLayoutDescriptor,
    ) -> WGPUPipelineLayout;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateQuerySet(
        device: WGPUDevice,
        descriptor: *const WGPUQuerySetDescriptor,
    ) -> WGPUQuerySet;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateRenderBundleEncoder(
        device: WGPUDevice,
        descriptor: *const WGPURenderBundleEncoderDescriptor,
    ) -> WGPURenderBundleEncoder;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateRenderPipeline(
        device: WGPUDevice,
        descriptor: *const WGPURenderPipelineDescriptor,
    ) -> WGPURenderPipeline;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateRenderPipelineAsync(
        device: WGPUDevice,
        descriptor: *const WGPURenderPipelineDescriptor,
        callbackInfo: WGPUCreateRenderPipelineAsyncCallbackInfo,
    ) -> WGPUFuture;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateSampler(
        device: WGPUDevice,
        descriptor: *const WGPUSamplerDescriptor,
    ) -> WGPUSampler;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateShaderModule(
        device: WGPUDevice,
        descriptor: *const WGPUShaderModuleDescriptor,
    ) -> WGPUShaderModule;
}
unsafe extern "C" {
    pub fn wgpuDeviceCreateTexture(
        device: WGPUDevice,
        descriptor: *const WGPUTextureDescriptor,
    ) -> WGPUTexture;
}
unsafe extern "C" {
    pub fn wgpuDeviceDestroy(device: WGPUDevice);
}
unsafe extern "C" {
    pub fn wgpuDeviceForceLoss(
        device: WGPUDevice,
        type_: WGPUDeviceLostReason,
        message: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuDeviceGetAdapter(device: WGPUDevice) -> WGPUAdapter;
}
unsafe extern "C" {
    pub fn wgpuDeviceGetAdapterInfo(
        device: WGPUDevice,
        adapterInfo: *mut WGPUAdapterInfo,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuDeviceGetAHardwareBufferProperties(
        device: WGPUDevice,
        handle: *mut ::core::ffi::c_void,
        properties: *mut WGPUAHardwareBufferProperties,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuDeviceGetFeatures(device: WGPUDevice, features: *mut WGPUSupportedFeatures);
}
unsafe extern "C" {
    pub fn wgpuDeviceGetLimits(device: WGPUDevice, limits: *mut WGPULimits) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuDeviceGetLostFuture(device: WGPUDevice) -> WGPUFuture;
}
unsafe extern "C" {
    pub fn wgpuDeviceGetQueue(device: WGPUDevice) -> WGPUQueue;
}
unsafe extern "C" {
    pub fn wgpuDeviceHasFeature(device: WGPUDevice, feature: WGPUFeatureName) -> WGPUBool;
}
unsafe extern "C" {
    pub fn wgpuDeviceImportSharedBufferMemory(
        device: WGPUDevice,
        descriptor: *const WGPUSharedBufferMemoryDescriptor,
    ) -> WGPUSharedBufferMemory;
}
unsafe extern "C" {
    pub fn wgpuDeviceImportSharedFence(
        device: WGPUDevice,
        descriptor: *const WGPUSharedFenceDescriptor,
    ) -> WGPUSharedFence;
}
unsafe extern "C" {
    pub fn wgpuDeviceImportSharedTextureMemory(
        device: WGPUDevice,
        descriptor: *const WGPUSharedTextureMemoryDescriptor,
    ) -> WGPUSharedTextureMemory;
}
unsafe extern "C" {
    pub fn wgpuDeviceInjectError(device: WGPUDevice, type_: WGPUErrorType, message: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuDevicePopErrorScope(
        device: WGPUDevice,
        callbackInfo: WGPUPopErrorScopeCallbackInfo,
    ) -> WGPUFuture;
}
unsafe extern "C" {
    pub fn wgpuDevicePushErrorScope(device: WGPUDevice, filter: WGPUErrorFilter);
}
unsafe extern "C" {
    pub fn wgpuDeviceSetLabel(device: WGPUDevice, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuDeviceSetLoggingCallback(device: WGPUDevice, callbackInfo: WGPULoggingCallbackInfo);
}
unsafe extern "C" {
    pub fn wgpuDeviceTick(device: WGPUDevice);
}
unsafe extern "C" {
    pub fn wgpuDeviceValidateTextureDescriptor(
        device: WGPUDevice,
        descriptor: *const WGPUTextureDescriptor,
    );
}
unsafe extern "C" {
    pub fn wgpuDeviceAddRef(device: WGPUDevice);
}
unsafe extern "C" {
    pub fn wgpuDeviceRelease(device: WGPUDevice);
}
unsafe extern "C" {
    pub fn wgpuExternalTextureDestroy(externalTexture: WGPUExternalTexture);
}
unsafe extern "C" {
    pub fn wgpuExternalTextureExpire(externalTexture: WGPUExternalTexture);
}
unsafe extern "C" {
    pub fn wgpuExternalTextureRefresh(externalTexture: WGPUExternalTexture);
}
unsafe extern "C" {
    pub fn wgpuExternalTextureSetLabel(externalTexture: WGPUExternalTexture, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuExternalTextureAddRef(externalTexture: WGPUExternalTexture);
}
unsafe extern "C" {
    pub fn wgpuExternalTextureRelease(externalTexture: WGPUExternalTexture);
}
unsafe extern "C" {
    pub fn wgpuInstanceCreateSurface(
        instance: WGPUInstance,
        descriptor: *const WGPUSurfaceDescriptor,
    ) -> WGPUSurface;
}
unsafe extern "C" {
    pub fn wgpuInstanceGetWGSLLanguageFeatures(
        instance: WGPUInstance,
        features: *mut WGPUSupportedWGSLLanguageFeatures,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuInstanceHasWGSLLanguageFeature(
        instance: WGPUInstance,
        feature: WGPUWGSLLanguageFeatureName,
    ) -> WGPUBool;
}
unsafe extern "C" {
    pub fn wgpuInstanceProcessEvents(instance: WGPUInstance);
}
unsafe extern "C" {
    pub fn wgpuInstanceRequestAdapter(
        instance: WGPUInstance,
        options: *const WGPURequestAdapterOptions,
        callbackInfo: WGPURequestAdapterCallbackInfo,
    ) -> WGPUFuture;
}
unsafe extern "C" {
    pub fn wgpuInstanceWaitAny(
        instance: WGPUInstance,
        futureCount: usize,
        futures: *mut WGPUFutureWaitInfo,
        timeoutNS: u64,
    ) -> WGPUWaitStatus;
}
unsafe extern "C" {
    pub fn wgpuInstanceAddRef(instance: WGPUInstance);
}
unsafe extern "C" {
    pub fn wgpuInstanceRelease(instance: WGPUInstance);
}
unsafe extern "C" {
    pub fn wgpuPipelineLayoutSetLabel(pipelineLayout: WGPUPipelineLayout, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuPipelineLayoutAddRef(pipelineLayout: WGPUPipelineLayout);
}
unsafe extern "C" {
    pub fn wgpuPipelineLayoutRelease(pipelineLayout: WGPUPipelineLayout);
}
unsafe extern "C" {
    pub fn wgpuQuerySetDestroy(querySet: WGPUQuerySet);
}
unsafe extern "C" {
    pub fn wgpuQuerySetGetCount(querySet: WGPUQuerySet) -> u32;
}
unsafe extern "C" {
    pub fn wgpuQuerySetGetType(querySet: WGPUQuerySet) -> WGPUQueryType;
}
unsafe extern "C" {
    pub fn wgpuQuerySetSetLabel(querySet: WGPUQuerySet, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuQuerySetAddRef(querySet: WGPUQuerySet);
}
unsafe extern "C" {
    pub fn wgpuQuerySetRelease(querySet: WGPUQuerySet);
}
unsafe extern "C" {
    pub fn wgpuQueueCopyExternalTextureForBrowser(
        queue: WGPUQueue,
        source: *const WGPUImageCopyExternalTexture,
        destination: *const WGPUTexelCopyTextureInfo,
        copySize: *const WGPUExtent3D,
        options: *const WGPUCopyTextureForBrowserOptions,
    );
}
unsafe extern "C" {
    pub fn wgpuQueueCopyTextureForBrowser(
        queue: WGPUQueue,
        source: *const WGPUTexelCopyTextureInfo,
        destination: *const WGPUTexelCopyTextureInfo,
        copySize: *const WGPUExtent3D,
        options: *const WGPUCopyTextureForBrowserOptions,
    );
}
unsafe extern "C" {
    pub fn wgpuQueueOnSubmittedWorkDone(
        queue: WGPUQueue,
        callbackInfo: WGPUQueueWorkDoneCallbackInfo,
    ) -> WGPUFuture;
}
unsafe extern "C" {
    pub fn wgpuQueueSetLabel(queue: WGPUQueue, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuQueueSubmit(
        queue: WGPUQueue,
        commandCount: usize,
        commands: *const WGPUCommandBuffer,
    );
}
unsafe extern "C" {
    pub fn wgpuQueueWriteBuffer(
        queue: WGPUQueue,
        buffer: WGPUBuffer,
        bufferOffset: u64,
        data: *const ::core::ffi::c_void,
        size: usize,
    );
}
unsafe extern "C" {
    pub fn wgpuQueueWriteTexture(
        queue: WGPUQueue,
        destination: *const WGPUTexelCopyTextureInfo,
        data: *const ::core::ffi::c_void,
        dataSize: usize,
        dataLayout: *const WGPUTexelCopyBufferLayout,
        writeSize: *const WGPUExtent3D,
    );
}
unsafe extern "C" {
    pub fn wgpuQueueAddRef(queue: WGPUQueue);
}
unsafe extern "C" {
    pub fn wgpuQueueRelease(queue: WGPUQueue);
}
unsafe extern "C" {
    pub fn wgpuRenderBundleSetLabel(renderBundle: WGPURenderBundle, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuRenderBundleAddRef(renderBundle: WGPURenderBundle);
}
unsafe extern "C" {
    pub fn wgpuRenderBundleRelease(renderBundle: WGPURenderBundle);
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderDraw(
        renderBundleEncoder: WGPURenderBundleEncoder,
        vertexCount: u32,
        instanceCount: u32,
        firstVertex: u32,
        firstInstance: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderDrawIndexed(
        renderBundleEncoder: WGPURenderBundleEncoder,
        indexCount: u32,
        instanceCount: u32,
        firstIndex: u32,
        baseVertex: i32,
        firstInstance: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderDrawIndexedIndirect(
        renderBundleEncoder: WGPURenderBundleEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderDrawIndirect(
        renderBundleEncoder: WGPURenderBundleEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderFinish(
        renderBundleEncoder: WGPURenderBundleEncoder,
        descriptor: *const WGPURenderBundleDescriptor,
    ) -> WGPURenderBundle;
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderInsertDebugMarker(
        renderBundleEncoder: WGPURenderBundleEncoder,
        markerLabel: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderPopDebugGroup(renderBundleEncoder: WGPURenderBundleEncoder);
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderPushDebugGroup(
        renderBundleEncoder: WGPURenderBundleEncoder,
        groupLabel: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderSetBindGroup(
        renderBundleEncoder: WGPURenderBundleEncoder,
        groupIndex: u32,
        group: WGPUBindGroup,
        dynamicOffsetCount: usize,
        dynamicOffsets: *const u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderSetImmediateData(
        renderBundleEncoder: WGPURenderBundleEncoder,
        offset: u32,
        data: *const ::core::ffi::c_void,
        size: usize,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderSetIndexBuffer(
        renderBundleEncoder: WGPURenderBundleEncoder,
        buffer: WGPUBuffer,
        format: WGPUIndexFormat,
        offset: u64,
        size: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderSetLabel(
        renderBundleEncoder: WGPURenderBundleEncoder,
        label: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderSetPipeline(
        renderBundleEncoder: WGPURenderBundleEncoder,
        pipeline: WGPURenderPipeline,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderSetVertexBuffer(
        renderBundleEncoder: WGPURenderBundleEncoder,
        slot: u32,
        buffer: WGPUBuffer,
        offset: u64,
        size: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderAddRef(renderBundleEncoder: WGPURenderBundleEncoder);
}
unsafe extern "C" {
    pub fn wgpuRenderBundleEncoderRelease(renderBundleEncoder: WGPURenderBundleEncoder);
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderBeginOcclusionQuery(
        renderPassEncoder: WGPURenderPassEncoder,
        queryIndex: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderDraw(
        renderPassEncoder: WGPURenderPassEncoder,
        vertexCount: u32,
        instanceCount: u32,
        firstVertex: u32,
        firstInstance: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderDrawIndexed(
        renderPassEncoder: WGPURenderPassEncoder,
        indexCount: u32,
        instanceCount: u32,
        firstIndex: u32,
        baseVertex: i32,
        firstInstance: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderDrawIndexedIndirect(
        renderPassEncoder: WGPURenderPassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderDrawIndirect(
        renderPassEncoder: WGPURenderPassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderEnd(renderPassEncoder: WGPURenderPassEncoder);
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderEndOcclusionQuery(renderPassEncoder: WGPURenderPassEncoder);
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderExecuteBundles(
        renderPassEncoder: WGPURenderPassEncoder,
        bundleCount: usize,
        bundles: *const WGPURenderBundle,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderInsertDebugMarker(
        renderPassEncoder: WGPURenderPassEncoder,
        markerLabel: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderMultiDrawIndexedIndirect(
        renderPassEncoder: WGPURenderPassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
        maxDrawCount: u32,
        drawCountBuffer: WGPUBuffer,
        drawCountBufferOffset: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderMultiDrawIndirect(
        renderPassEncoder: WGPURenderPassEncoder,
        indirectBuffer: WGPUBuffer,
        indirectOffset: u64,
        maxDrawCount: u32,
        drawCountBuffer: WGPUBuffer,
        drawCountBufferOffset: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderPixelLocalStorageBarrier(renderPassEncoder: WGPURenderPassEncoder);
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderPopDebugGroup(renderPassEncoder: WGPURenderPassEncoder);
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderPushDebugGroup(
        renderPassEncoder: WGPURenderPassEncoder,
        groupLabel: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetBindGroup(
        renderPassEncoder: WGPURenderPassEncoder,
        groupIndex: u32,
        group: WGPUBindGroup,
        dynamicOffsetCount: usize,
        dynamicOffsets: *const u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetBlendConstant(
        renderPassEncoder: WGPURenderPassEncoder,
        color: *const WGPUColor,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetImmediateData(
        renderPassEncoder: WGPURenderPassEncoder,
        offset: u32,
        data: *const ::core::ffi::c_void,
        size: usize,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetIndexBuffer(
        renderPassEncoder: WGPURenderPassEncoder,
        buffer: WGPUBuffer,
        format: WGPUIndexFormat,
        offset: u64,
        size: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetLabel(
        renderPassEncoder: WGPURenderPassEncoder,
        label: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetPipeline(
        renderPassEncoder: WGPURenderPassEncoder,
        pipeline: WGPURenderPipeline,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetScissorRect(
        renderPassEncoder: WGPURenderPassEncoder,
        x: u32,
        y: u32,
        width: u32,
        height: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetStencilReference(
        renderPassEncoder: WGPURenderPassEncoder,
        reference: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetVertexBuffer(
        renderPassEncoder: WGPURenderPassEncoder,
        slot: u32,
        buffer: WGPUBuffer,
        offset: u64,
        size: u64,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderSetViewport(
        renderPassEncoder: WGPURenderPassEncoder,
        x: f32,
        y: f32,
        width: f32,
        height: f32,
        minDepth: f32,
        maxDepth: f32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderWriteTimestamp(
        renderPassEncoder: WGPURenderPassEncoder,
        querySet: WGPUQuerySet,
        queryIndex: u32,
    );
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderAddRef(renderPassEncoder: WGPURenderPassEncoder);
}
unsafe extern "C" {
    pub fn wgpuRenderPassEncoderRelease(renderPassEncoder: WGPURenderPassEncoder);
}
unsafe extern "C" {
    pub fn wgpuRenderPipelineGetBindGroupLayout(
        renderPipeline: WGPURenderPipeline,
        groupIndex: u32,
    ) -> WGPUBindGroupLayout;
}
unsafe extern "C" {
    pub fn wgpuRenderPipelineSetLabel(renderPipeline: WGPURenderPipeline, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuRenderPipelineAddRef(renderPipeline: WGPURenderPipeline);
}
unsafe extern "C" {
    pub fn wgpuRenderPipelineRelease(renderPipeline: WGPURenderPipeline);
}
unsafe extern "C" {
    pub fn wgpuSamplerSetLabel(sampler: WGPUSampler, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuSamplerAddRef(sampler: WGPUSampler);
}
unsafe extern "C" {
    pub fn wgpuSamplerRelease(sampler: WGPUSampler);
}
unsafe extern "C" {
    pub fn wgpuShaderModuleGetCompilationInfo(
        shaderModule: WGPUShaderModule,
        callbackInfo: WGPUCompilationInfoCallbackInfo,
    ) -> WGPUFuture;
}
unsafe extern "C" {
    pub fn wgpuShaderModuleSetLabel(shaderModule: WGPUShaderModule, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuShaderModuleAddRef(shaderModule: WGPUShaderModule);
}
unsafe extern "C" {
    pub fn wgpuShaderModuleRelease(shaderModule: WGPUShaderModule);
}
unsafe extern "C" {
    pub fn wgpuSharedBufferMemoryBeginAccess(
        sharedBufferMemory: WGPUSharedBufferMemory,
        buffer: WGPUBuffer,
        descriptor: *const WGPUSharedBufferMemoryBeginAccessDescriptor,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuSharedBufferMemoryCreateBuffer(
        sharedBufferMemory: WGPUSharedBufferMemory,
        descriptor: *const WGPUBufferDescriptor,
    ) -> WGPUBuffer;
}
unsafe extern "C" {
    pub fn wgpuSharedBufferMemoryEndAccess(
        sharedBufferMemory: WGPUSharedBufferMemory,
        buffer: WGPUBuffer,
        descriptor: *mut WGPUSharedBufferMemoryEndAccessState,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuSharedBufferMemoryGetProperties(
        sharedBufferMemory: WGPUSharedBufferMemory,
        properties: *mut WGPUSharedBufferMemoryProperties,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuSharedBufferMemoryIsDeviceLost(
        sharedBufferMemory: WGPUSharedBufferMemory,
    ) -> WGPUBool;
}
unsafe extern "C" {
    pub fn wgpuSharedBufferMemorySetLabel(
        sharedBufferMemory: WGPUSharedBufferMemory,
        label: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuSharedBufferMemoryAddRef(sharedBufferMemory: WGPUSharedBufferMemory);
}
unsafe extern "C" {
    pub fn wgpuSharedBufferMemoryRelease(sharedBufferMemory: WGPUSharedBufferMemory);
}
unsafe extern "C" {
    pub fn wgpuSharedFenceExportInfo(
        sharedFence: WGPUSharedFence,
        info: *mut WGPUSharedFenceExportInfo,
    );
}
unsafe extern "C" {
    pub fn wgpuSharedFenceAddRef(sharedFence: WGPUSharedFence);
}
unsafe extern "C" {
    pub fn wgpuSharedFenceRelease(sharedFence: WGPUSharedFence);
}
unsafe extern "C" {
    pub fn wgpuSharedTextureMemoryBeginAccess(
        sharedTextureMemory: WGPUSharedTextureMemory,
        texture: WGPUTexture,
        descriptor: *const WGPUSharedTextureMemoryBeginAccessDescriptor,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuSharedTextureMemoryCreateTexture(
        sharedTextureMemory: WGPUSharedTextureMemory,
        descriptor: *const WGPUTextureDescriptor,
    ) -> WGPUTexture;
}
unsafe extern "C" {
    pub fn wgpuSharedTextureMemoryEndAccess(
        sharedTextureMemory: WGPUSharedTextureMemory,
        texture: WGPUTexture,
        descriptor: *mut WGPUSharedTextureMemoryEndAccessState,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuSharedTextureMemoryGetProperties(
        sharedTextureMemory: WGPUSharedTextureMemory,
        properties: *mut WGPUSharedTextureMemoryProperties,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuSharedTextureMemoryIsDeviceLost(
        sharedTextureMemory: WGPUSharedTextureMemory,
    ) -> WGPUBool;
}
unsafe extern "C" {
    pub fn wgpuSharedTextureMemorySetLabel(
        sharedTextureMemory: WGPUSharedTextureMemory,
        label: WGPUStringView,
    );
}
unsafe extern "C" {
    pub fn wgpuSharedTextureMemoryAddRef(sharedTextureMemory: WGPUSharedTextureMemory);
}
unsafe extern "C" {
    pub fn wgpuSharedTextureMemoryRelease(sharedTextureMemory: WGPUSharedTextureMemory);
}
unsafe extern "C" {
    pub fn wgpuSurfaceConfigure(surface: WGPUSurface, config: *const WGPUSurfaceConfiguration);
}
unsafe extern "C" {
    pub fn wgpuSurfaceGetCapabilities(
        surface: WGPUSurface,
        adapter: WGPUAdapter,
        capabilities: *mut WGPUSurfaceCapabilities,
    ) -> WGPUStatus;
}
unsafe extern "C" {
    pub fn wgpuSurfaceGetCurrentTexture(
        surface: WGPUSurface,
        surfaceTexture: *mut WGPUSurfaceTexture,
    );
}
unsafe extern "C" {
    pub fn wgpuSurfacePresent(surface: WGPUSurface);
}
unsafe extern "C" {
    pub fn wgpuSurfaceSetLabel(surface: WGPUSurface, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuSurfaceUnconfigure(surface: WGPUSurface);
}
unsafe extern "C" {
    pub fn wgpuSurfaceAddRef(surface: WGPUSurface);
}
unsafe extern "C" {
    pub fn wgpuSurfaceRelease(surface: WGPUSurface);
}
unsafe extern "C" {
    pub fn wgpuTextureCreateErrorView(
        texture: WGPUTexture,
        descriptor: *const WGPUTextureViewDescriptor,
    ) -> WGPUTextureView;
}
unsafe extern "C" {
    pub fn wgpuTextureCreateView(
        texture: WGPUTexture,
        descriptor: *const WGPUTextureViewDescriptor,
    ) -> WGPUTextureView;
}
unsafe extern "C" {
    pub fn wgpuTextureDestroy(texture: WGPUTexture);
}
unsafe extern "C" {
    pub fn wgpuTextureGetDepthOrArrayLayers(texture: WGPUTexture) -> u32;
}
unsafe extern "C" {
    pub fn wgpuTextureGetDimension(texture: WGPUTexture) -> WGPUTextureDimension;
}
unsafe extern "C" {
    pub fn wgpuTextureGetFormat(texture: WGPUTexture) -> WGPUTextureFormat;
}
unsafe extern "C" {
    pub fn wgpuTextureGetHeight(texture: WGPUTexture) -> u32;
}
unsafe extern "C" {
    pub fn wgpuTextureGetMipLevelCount(texture: WGPUTexture) -> u32;
}
unsafe extern "C" {
    pub fn wgpuTextureGetSampleCount(texture: WGPUTexture) -> u32;
}
unsafe extern "C" {
    pub fn wgpuTextureGetUsage(texture: WGPUTexture) -> WGPUTextureUsage;
}
unsafe extern "C" {
    pub fn wgpuTextureGetWidth(texture: WGPUTexture) -> u32;
}
unsafe extern "C" {
    pub fn wgpuTextureSetLabel(texture: WGPUTexture, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuTextureAddRef(texture: WGPUTexture);
}
unsafe extern "C" {
    pub fn wgpuTextureRelease(texture: WGPUTexture);
}
unsafe extern "C" {
    pub fn wgpuTextureViewSetLabel(textureView: WGPUTextureView, label: WGPUStringView);
}
unsafe extern "C" {
    pub fn wgpuTextureViewAddRef(textureView: WGPUTextureView);
}
unsafe extern "C" {
    pub fn wgpuTextureViewRelease(textureView: WGPUTextureView);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __crt_locale_data {
    pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
pub struct __crt_multibyte_data {
    pub _address: u8,
}