script_bindings/home/runner/work/servo/servo/target/debug/build/script_bindings-d55f55d5af1efaee/out/Bindings/

WebGPUBinding.rs

/* THIS FILE IS AUTOGENERATED - DO NOT EDIT */

#![allow(non_camel_case_types,non_upper_case_globals,unsafe_op_in_unsafe_fn,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::enum_variant_names,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]

use crate::codegen::GenericBindings::DOMExceptionBinding::DOMException_Binding;
use crate::codegen::GenericBindings::EventBinding::Event_Binding;
use crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull;
use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
use crate::import::base::*;
use crate::record::Record;


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUPowerPreference {
    Low_power,
    High_performance
}
pub mod GPUPowerPreferenceValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUPowerPreference)] = &[
        ("low-power", super::GPUPowerPreference::Low_power),
        ("high-performance", super::GPUPowerPreference::High_performance),
    ];

    impl super::GPUPowerPreference {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUPowerPreference {
        fn default() -> super::GPUPowerPreference {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUPowerPreference {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUPowerPreference {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUPowerPreference {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUPowerPreference>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUPowerPreference'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUPowerPreferenceValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq, Eq, Hash)]
pub enum GPUFeatureName {
    Depth_clip_control,
    Depth32float_stencil8,
    Texture_compression_bc,
    Texture_compression_bc_sliced_3d,
    Texture_compression_etc2,
    Texture_compression_astc,
    Timestamp_query,
    Indirect_first_instance,
    Shader_f16,
    Rg11b10ufloat_renderable,
    Bgra8unorm_storage,
    Float32_filterable,
    Clip_distances,
    Dual_source_blending,
    Subgroups
}
pub mod GPUFeatureNameValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUFeatureName)] = &[
        ("depth-clip-control", super::GPUFeatureName::Depth_clip_control),
        ("depth32float-stencil8", super::GPUFeatureName::Depth32float_stencil8),
        ("texture-compression-bc", super::GPUFeatureName::Texture_compression_bc),
        ("texture-compression-bc-sliced-3d", super::GPUFeatureName::Texture_compression_bc_sliced_3d),
        ("texture-compression-etc2", super::GPUFeatureName::Texture_compression_etc2),
        ("texture-compression-astc", super::GPUFeatureName::Texture_compression_astc),
        ("timestamp-query", super::GPUFeatureName::Timestamp_query),
        ("indirect-first-instance", super::GPUFeatureName::Indirect_first_instance),
        ("shader-f16", super::GPUFeatureName::Shader_f16),
        ("rg11b10ufloat-renderable", super::GPUFeatureName::Rg11b10ufloat_renderable),
        ("bgra8unorm-storage", super::GPUFeatureName::Bgra8unorm_storage),
        ("float32-filterable", super::GPUFeatureName::Float32_filterable),
        ("clip-distances", super::GPUFeatureName::Clip_distances),
        ("dual-source-blending", super::GPUFeatureName::Dual_source_blending),
        ("subgroups", super::GPUFeatureName::Subgroups),
    ];

    impl super::GPUFeatureName {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUFeatureName {
        fn default() -> super::GPUFeatureName {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUFeatureName {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUFeatureName {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUFeatureName {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUFeatureName>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUFeatureName'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUFeatureNameValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUBufferMapState {
    Unmapped,
    Pending,
    Mapped
}
pub mod GPUBufferMapStateValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUBufferMapState)] = &[
        ("unmapped", super::GPUBufferMapState::Unmapped),
        ("pending", super::GPUBufferMapState::Pending),
        ("mapped", super::GPUBufferMapState::Mapped),
    ];

    impl super::GPUBufferMapState {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUBufferMapState {
        fn default() -> super::GPUBufferMapState {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUBufferMapState {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUBufferMapState {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUBufferMapState {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUBufferMapState>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUBufferMapState'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUBufferMapStateValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUTextureDimension {
    _1d,
    _2d,
    _3d
}
pub mod GPUTextureDimensionValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUTextureDimension)] = &[
        ("1d", super::GPUTextureDimension::_1d),
        ("2d", super::GPUTextureDimension::_2d),
        ("3d", super::GPUTextureDimension::_3d),
    ];

    impl super::GPUTextureDimension {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUTextureDimension {
        fn default() -> super::GPUTextureDimension {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUTextureDimension {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUTextureDimension {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUTextureDimension {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUTextureDimension>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUTextureDimension'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUTextureDimensionValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUTextureViewDimension {
    _1d,
    _2d,
    _2d_array,
    Cube,
    Cube_array,
    _3d
}
pub mod GPUTextureViewDimensionValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUTextureViewDimension)] = &[
        ("1d", super::GPUTextureViewDimension::_1d),
        ("2d", super::GPUTextureViewDimension::_2d),
        ("2d-array", super::GPUTextureViewDimension::_2d_array),
        ("cube", super::GPUTextureViewDimension::Cube),
        ("cube-array", super::GPUTextureViewDimension::Cube_array),
        ("3d", super::GPUTextureViewDimension::_3d),
    ];

    impl super::GPUTextureViewDimension {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUTextureViewDimension {
        fn default() -> super::GPUTextureViewDimension {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUTextureViewDimension {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUTextureViewDimension {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUTextureViewDimension {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUTextureViewDimension>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUTextureViewDimension'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUTextureViewDimensionValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUTextureAspect {
    All,
    Stencil_only,
    Depth_only
}
pub mod GPUTextureAspectValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUTextureAspect)] = &[
        ("all", super::GPUTextureAspect::All),
        ("stencil-only", super::GPUTextureAspect::Stencil_only),
        ("depth-only", super::GPUTextureAspect::Depth_only),
    ];

    impl super::GPUTextureAspect {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUTextureAspect {
        fn default() -> super::GPUTextureAspect {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUTextureAspect {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUTextureAspect {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUTextureAspect {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUTextureAspect>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUTextureAspect'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUTextureAspectValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUTextureFormat {
    R8unorm,
    R8snorm,
    R8uint,
    R8sint,
    R16uint,
    R16sint,
    R16float,
    Rg8unorm,
    Rg8snorm,
    Rg8uint,
    Rg8sint,
    R32uint,
    R32sint,
    R32float,
    Rg16uint,
    Rg16sint,
    Rg16float,
    Rgba8unorm,
    Rgba8unorm_srgb,
    Rgba8snorm,
    Rgba8uint,
    Rgba8sint,
    Bgra8unorm,
    Bgra8unorm_srgb,
    Rgb9e5ufloat,
    Rgb10a2uint,
    Rgb10a2unorm,
    Rg11b10ufloat,
    Rg32uint,
    Rg32sint,
    Rg32float,
    Rgba16uint,
    Rgba16sint,
    Rgba16float,
    Rgba32uint,
    Rgba32sint,
    Rgba32float,
    Stencil8,
    Depth16unorm,
    Depth24plus,
    Depth24plus_stencil8,
    Depth32float,
    Depth32float_stencil8,
    Bc1_rgba_unorm,
    Bc1_rgba_unorm_srgb,
    Bc2_rgba_unorm,
    Bc2_rgba_unorm_srgb,
    Bc3_rgba_unorm,
    Bc3_rgba_unorm_srgb,
    Bc4_r_unorm,
    Bc4_r_snorm,
    Bc5_rg_unorm,
    Bc5_rg_snorm,
    Bc6h_rgb_ufloat,
    Bc6h_rgb_float,
    Bc7_rgba_unorm,
    Bc7_rgba_unorm_srgb,
    Etc2_rgb8unorm,
    Etc2_rgb8unorm_srgb,
    Etc2_rgb8a1unorm,
    Etc2_rgb8a1unorm_srgb,
    Etc2_rgba8unorm,
    Etc2_rgba8unorm_srgb,
    Eac_r11unorm,
    Eac_r11snorm,
    Eac_rg11unorm,
    Eac_rg11snorm,
    Astc_4x4_unorm,
    Astc_4x4_unorm_srgb,
    Astc_5x4_unorm,
    Astc_5x4_unorm_srgb,
    Astc_5x5_unorm,
    Astc_5x5_unorm_srgb,
    Astc_6x5_unorm,
    Astc_6x5_unorm_srgb,
    Astc_6x6_unorm,
    Astc_6x6_unorm_srgb,
    Astc_8x5_unorm,
    Astc_8x5_unorm_srgb,
    Astc_8x6_unorm,
    Astc_8x6_unorm_srgb,
    Astc_8x8_unorm,
    Astc_8x8_unorm_srgb,
    Astc_10x5_unorm,
    Astc_10x5_unorm_srgb,
    Astc_10x6_unorm,
    Astc_10x6_unorm_srgb,
    Astc_10x8_unorm,
    Astc_10x8_unorm_srgb,
    Astc_10x10_unorm,
    Astc_10x10_unorm_srgb,
    Astc_12x10_unorm,
    Astc_12x10_unorm_srgb,
    Astc_12x12_unorm,
    Astc_12x12_unorm_srgb
}
pub mod GPUTextureFormatValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUTextureFormat)] = &[
        ("r8unorm", super::GPUTextureFormat::R8unorm),
        ("r8snorm", super::GPUTextureFormat::R8snorm),
        ("r8uint", super::GPUTextureFormat::R8uint),
        ("r8sint", super::GPUTextureFormat::R8sint),
        ("r16uint", super::GPUTextureFormat::R16uint),
        ("r16sint", super::GPUTextureFormat::R16sint),
        ("r16float", super::GPUTextureFormat::R16float),
        ("rg8unorm", super::GPUTextureFormat::Rg8unorm),
        ("rg8snorm", super::GPUTextureFormat::Rg8snorm),
        ("rg8uint", super::GPUTextureFormat::Rg8uint),
        ("rg8sint", super::GPUTextureFormat::Rg8sint),
        ("r32uint", super::GPUTextureFormat::R32uint),
        ("r32sint", super::GPUTextureFormat::R32sint),
        ("r32float", super::GPUTextureFormat::R32float),
        ("rg16uint", super::GPUTextureFormat::Rg16uint),
        ("rg16sint", super::GPUTextureFormat::Rg16sint),
        ("rg16float", super::GPUTextureFormat::Rg16float),
        ("rgba8unorm", super::GPUTextureFormat::Rgba8unorm),
        ("rgba8unorm-srgb", super::GPUTextureFormat::Rgba8unorm_srgb),
        ("rgba8snorm", super::GPUTextureFormat::Rgba8snorm),
        ("rgba8uint", super::GPUTextureFormat::Rgba8uint),
        ("rgba8sint", super::GPUTextureFormat::Rgba8sint),
        ("bgra8unorm", super::GPUTextureFormat::Bgra8unorm),
        ("bgra8unorm-srgb", super::GPUTextureFormat::Bgra8unorm_srgb),
        ("rgb9e5ufloat", super::GPUTextureFormat::Rgb9e5ufloat),
        ("rgb10a2uint", super::GPUTextureFormat::Rgb10a2uint),
        ("rgb10a2unorm", super::GPUTextureFormat::Rgb10a2unorm),
        ("rg11b10ufloat", super::GPUTextureFormat::Rg11b10ufloat),
        ("rg32uint", super::GPUTextureFormat::Rg32uint),
        ("rg32sint", super::GPUTextureFormat::Rg32sint),
        ("rg32float", super::GPUTextureFormat::Rg32float),
        ("rgba16uint", super::GPUTextureFormat::Rgba16uint),
        ("rgba16sint", super::GPUTextureFormat::Rgba16sint),
        ("rgba16float", super::GPUTextureFormat::Rgba16float),
        ("rgba32uint", super::GPUTextureFormat::Rgba32uint),
        ("rgba32sint", super::GPUTextureFormat::Rgba32sint),
        ("rgba32float", super::GPUTextureFormat::Rgba32float),
        ("stencil8", super::GPUTextureFormat::Stencil8),
        ("depth16unorm", super::GPUTextureFormat::Depth16unorm),
        ("depth24plus", super::GPUTextureFormat::Depth24plus),
        ("depth24plus-stencil8", super::GPUTextureFormat::Depth24plus_stencil8),
        ("depth32float", super::GPUTextureFormat::Depth32float),
        ("depth32float-stencil8", super::GPUTextureFormat::Depth32float_stencil8),
        ("bc1-rgba-unorm", super::GPUTextureFormat::Bc1_rgba_unorm),
        ("bc1-rgba-unorm-srgb", super::GPUTextureFormat::Bc1_rgba_unorm_srgb),
        ("bc2-rgba-unorm", super::GPUTextureFormat::Bc2_rgba_unorm),
        ("bc2-rgba-unorm-srgb", super::GPUTextureFormat::Bc2_rgba_unorm_srgb),
        ("bc3-rgba-unorm", super::GPUTextureFormat::Bc3_rgba_unorm),
        ("bc3-rgba-unorm-srgb", super::GPUTextureFormat::Bc3_rgba_unorm_srgb),
        ("bc4-r-unorm", super::GPUTextureFormat::Bc4_r_unorm),
        ("bc4-r-snorm", super::GPUTextureFormat::Bc4_r_snorm),
        ("bc5-rg-unorm", super::GPUTextureFormat::Bc5_rg_unorm),
        ("bc5-rg-snorm", super::GPUTextureFormat::Bc5_rg_snorm),
        ("bc6h-rgb-ufloat", super::GPUTextureFormat::Bc6h_rgb_ufloat),
        ("bc6h-rgb-float", super::GPUTextureFormat::Bc6h_rgb_float),
        ("bc7-rgba-unorm", super::GPUTextureFormat::Bc7_rgba_unorm),
        ("bc7-rgba-unorm-srgb", super::GPUTextureFormat::Bc7_rgba_unorm_srgb),
        ("etc2-rgb8unorm", super::GPUTextureFormat::Etc2_rgb8unorm),
        ("etc2-rgb8unorm-srgb", super::GPUTextureFormat::Etc2_rgb8unorm_srgb),
        ("etc2-rgb8a1unorm", super::GPUTextureFormat::Etc2_rgb8a1unorm),
        ("etc2-rgb8a1unorm-srgb", super::GPUTextureFormat::Etc2_rgb8a1unorm_srgb),
        ("etc2-rgba8unorm", super::GPUTextureFormat::Etc2_rgba8unorm),
        ("etc2-rgba8unorm-srgb", super::GPUTextureFormat::Etc2_rgba8unorm_srgb),
        ("eac-r11unorm", super::GPUTextureFormat::Eac_r11unorm),
        ("eac-r11snorm", super::GPUTextureFormat::Eac_r11snorm),
        ("eac-rg11unorm", super::GPUTextureFormat::Eac_rg11unorm),
        ("eac-rg11snorm", super::GPUTextureFormat::Eac_rg11snorm),
        ("astc-4x4-unorm", super::GPUTextureFormat::Astc_4x4_unorm),
        ("astc-4x4-unorm-srgb", super::GPUTextureFormat::Astc_4x4_unorm_srgb),
        ("astc-5x4-unorm", super::GPUTextureFormat::Astc_5x4_unorm),
        ("astc-5x4-unorm-srgb", super::GPUTextureFormat::Astc_5x4_unorm_srgb),
        ("astc-5x5-unorm", super::GPUTextureFormat::Astc_5x5_unorm),
        ("astc-5x5-unorm-srgb", super::GPUTextureFormat::Astc_5x5_unorm_srgb),
        ("astc-6x5-unorm", super::GPUTextureFormat::Astc_6x5_unorm),
        ("astc-6x5-unorm-srgb", super::GPUTextureFormat::Astc_6x5_unorm_srgb),
        ("astc-6x6-unorm", super::GPUTextureFormat::Astc_6x6_unorm),
        ("astc-6x6-unorm-srgb", super::GPUTextureFormat::Astc_6x6_unorm_srgb),
        ("astc-8x5-unorm", super::GPUTextureFormat::Astc_8x5_unorm),
        ("astc-8x5-unorm-srgb", super::GPUTextureFormat::Astc_8x5_unorm_srgb),
        ("astc-8x6-unorm", super::GPUTextureFormat::Astc_8x6_unorm),
        ("astc-8x6-unorm-srgb", super::GPUTextureFormat::Astc_8x6_unorm_srgb),
        ("astc-8x8-unorm", super::GPUTextureFormat::Astc_8x8_unorm),
        ("astc-8x8-unorm-srgb", super::GPUTextureFormat::Astc_8x8_unorm_srgb),
        ("astc-10x5-unorm", super::GPUTextureFormat::Astc_10x5_unorm),
        ("astc-10x5-unorm-srgb", super::GPUTextureFormat::Astc_10x5_unorm_srgb),
        ("astc-10x6-unorm", super::GPUTextureFormat::Astc_10x6_unorm),
        ("astc-10x6-unorm-srgb", super::GPUTextureFormat::Astc_10x6_unorm_srgb),
        ("astc-10x8-unorm", super::GPUTextureFormat::Astc_10x8_unorm),
        ("astc-10x8-unorm-srgb", super::GPUTextureFormat::Astc_10x8_unorm_srgb),
        ("astc-10x10-unorm", super::GPUTextureFormat::Astc_10x10_unorm),
        ("astc-10x10-unorm-srgb", super::GPUTextureFormat::Astc_10x10_unorm_srgb),
        ("astc-12x10-unorm", super::GPUTextureFormat::Astc_12x10_unorm),
        ("astc-12x10-unorm-srgb", super::GPUTextureFormat::Astc_12x10_unorm_srgb),
        ("astc-12x12-unorm", super::GPUTextureFormat::Astc_12x12_unorm),
        ("astc-12x12-unorm-srgb", super::GPUTextureFormat::Astc_12x12_unorm_srgb),
    ];

    impl super::GPUTextureFormat {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUTextureFormat {
        fn default() -> super::GPUTextureFormat {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUTextureFormat {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUTextureFormat {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUTextureFormat {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUTextureFormat>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUTextureFormat'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUTextureFormatValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUAddressMode {
    Clamp_to_edge,
    Repeat,
    Mirror_repeat
}
pub mod GPUAddressModeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUAddressMode)] = &[
        ("clamp-to-edge", super::GPUAddressMode::Clamp_to_edge),
        ("repeat", super::GPUAddressMode::Repeat),
        ("mirror-repeat", super::GPUAddressMode::Mirror_repeat),
    ];

    impl super::GPUAddressMode {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUAddressMode {
        fn default() -> super::GPUAddressMode {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUAddressMode {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUAddressMode {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUAddressMode {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUAddressMode>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUAddressMode'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUAddressModeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUFilterMode {
    Nearest,
    Linear
}
pub mod GPUFilterModeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUFilterMode)] = &[
        ("nearest", super::GPUFilterMode::Nearest),
        ("linear", super::GPUFilterMode::Linear),
    ];

    impl super::GPUFilterMode {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUFilterMode {
        fn default() -> super::GPUFilterMode {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUFilterMode {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUFilterMode {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUFilterMode {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUFilterMode>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUFilterMode'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUFilterModeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUCompareFunction {
    Never,
    Less,
    Equal,
    Less_equal,
    Greater,
    Not_equal,
    Greater_equal,
    Always
}
pub mod GPUCompareFunctionValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUCompareFunction)] = &[
        ("never", super::GPUCompareFunction::Never),
        ("less", super::GPUCompareFunction::Less),
        ("equal", super::GPUCompareFunction::Equal),
        ("less-equal", super::GPUCompareFunction::Less_equal),
        ("greater", super::GPUCompareFunction::Greater),
        ("not-equal", super::GPUCompareFunction::Not_equal),
        ("greater-equal", super::GPUCompareFunction::Greater_equal),
        ("always", super::GPUCompareFunction::Always),
    ];

    impl super::GPUCompareFunction {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUCompareFunction {
        fn default() -> super::GPUCompareFunction {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUCompareFunction {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUCompareFunction {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUCompareFunction {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUCompareFunction>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUCompareFunction'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUCompareFunctionValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUBufferBindingType {
    Uniform,
    Storage,
    Read_only_storage
}
pub mod GPUBufferBindingTypeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUBufferBindingType)] = &[
        ("uniform", super::GPUBufferBindingType::Uniform),
        ("storage", super::GPUBufferBindingType::Storage),
        ("read-only-storage", super::GPUBufferBindingType::Read_only_storage),
    ];

    impl super::GPUBufferBindingType {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUBufferBindingType {
        fn default() -> super::GPUBufferBindingType {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUBufferBindingType {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUBufferBindingType {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUBufferBindingType {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUBufferBindingType>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUBufferBindingType'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUBufferBindingTypeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUSamplerBindingType {
    Filtering,
    Non_filtering,
    Comparison
}
pub mod GPUSamplerBindingTypeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUSamplerBindingType)] = &[
        ("filtering", super::GPUSamplerBindingType::Filtering),
        ("non-filtering", super::GPUSamplerBindingType::Non_filtering),
        ("comparison", super::GPUSamplerBindingType::Comparison),
    ];

    impl super::GPUSamplerBindingType {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUSamplerBindingType {
        fn default() -> super::GPUSamplerBindingType {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUSamplerBindingType {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUSamplerBindingType {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUSamplerBindingType {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUSamplerBindingType>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUSamplerBindingType'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUSamplerBindingTypeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUTextureSampleType {
    Float,
    Unfilterable_float,
    Depth,
    Sint,
    Uint
}
pub mod GPUTextureSampleTypeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUTextureSampleType)] = &[
        ("float", super::GPUTextureSampleType::Float),
        ("unfilterable-float", super::GPUTextureSampleType::Unfilterable_float),
        ("depth", super::GPUTextureSampleType::Depth),
        ("sint", super::GPUTextureSampleType::Sint),
        ("uint", super::GPUTextureSampleType::Uint),
    ];

    impl super::GPUTextureSampleType {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUTextureSampleType {
        fn default() -> super::GPUTextureSampleType {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUTextureSampleType {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUTextureSampleType {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUTextureSampleType {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUTextureSampleType>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUTextureSampleType'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUTextureSampleTypeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUStorageTextureAccess {
    Write_only,
    Read_only,
    Read_write
}
pub mod GPUStorageTextureAccessValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUStorageTextureAccess)] = &[
        ("write-only", super::GPUStorageTextureAccess::Write_only),
        ("read-only", super::GPUStorageTextureAccess::Read_only),
        ("read-write", super::GPUStorageTextureAccess::Read_write),
    ];

    impl super::GPUStorageTextureAccess {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUStorageTextureAccess {
        fn default() -> super::GPUStorageTextureAccess {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUStorageTextureAccess {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUStorageTextureAccess {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUStorageTextureAccess {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUStorageTextureAccess>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUStorageTextureAccess'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUStorageTextureAccessValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUCompilationMessageType {
    Error,
    Warning,
    Info
}
pub mod GPUCompilationMessageTypeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUCompilationMessageType)] = &[
        ("error", super::GPUCompilationMessageType::Error),
        ("warning", super::GPUCompilationMessageType::Warning),
        ("info", super::GPUCompilationMessageType::Info),
    ];

    impl super::GPUCompilationMessageType {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUCompilationMessageType {
        fn default() -> super::GPUCompilationMessageType {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUCompilationMessageType {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUCompilationMessageType {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUCompilationMessageType {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUCompilationMessageType>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUCompilationMessageType'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUCompilationMessageTypeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUPipelineErrorReason {
    Validation,
    Internal
}
pub mod GPUPipelineErrorReasonValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUPipelineErrorReason)] = &[
        ("validation", super::GPUPipelineErrorReason::Validation),
        ("internal", super::GPUPipelineErrorReason::Internal),
    ];

    impl super::GPUPipelineErrorReason {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUPipelineErrorReason {
        fn default() -> super::GPUPipelineErrorReason {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUPipelineErrorReason {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUPipelineErrorReason {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUPipelineErrorReason {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUPipelineErrorReason>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUPipelineErrorReason'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUPipelineErrorReasonValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUAutoLayoutMode {
    Auto
}
pub mod GPUAutoLayoutModeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUAutoLayoutMode)] = &[
        ("auto", super::GPUAutoLayoutMode::Auto),
    ];

    impl super::GPUAutoLayoutMode {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUAutoLayoutMode {
        fn default() -> super::GPUAutoLayoutMode {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUAutoLayoutMode {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUAutoLayoutMode {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUAutoLayoutMode {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUAutoLayoutMode>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUAutoLayoutMode'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUAutoLayoutModeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUPrimitiveTopology {
    Point_list,
    Line_list,
    Line_strip,
    Triangle_list,
    Triangle_strip
}
pub mod GPUPrimitiveTopologyValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUPrimitiveTopology)] = &[
        ("point-list", super::GPUPrimitiveTopology::Point_list),
        ("line-list", super::GPUPrimitiveTopology::Line_list),
        ("line-strip", super::GPUPrimitiveTopology::Line_strip),
        ("triangle-list", super::GPUPrimitiveTopology::Triangle_list),
        ("triangle-strip", super::GPUPrimitiveTopology::Triangle_strip),
    ];

    impl super::GPUPrimitiveTopology {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUPrimitiveTopology {
        fn default() -> super::GPUPrimitiveTopology {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUPrimitiveTopology {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUPrimitiveTopology {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUPrimitiveTopology {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUPrimitiveTopology>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUPrimitiveTopology'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUPrimitiveTopologyValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUFrontFace {
    Ccw,
    Cw
}
pub mod GPUFrontFaceValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUFrontFace)] = &[
        ("ccw", super::GPUFrontFace::Ccw),
        ("cw", super::GPUFrontFace::Cw),
    ];

    impl super::GPUFrontFace {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUFrontFace {
        fn default() -> super::GPUFrontFace {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUFrontFace {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUFrontFace {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUFrontFace {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUFrontFace>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUFrontFace'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUFrontFaceValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUCullMode {
    None,
    Front,
    Back
}
pub mod GPUCullModeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUCullMode)] = &[
        ("none", super::GPUCullMode::None),
        ("front", super::GPUCullMode::Front),
        ("back", super::GPUCullMode::Back),
    ];

    impl super::GPUCullMode {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUCullMode {
        fn default() -> super::GPUCullMode {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUCullMode {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUCullMode {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUCullMode {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUCullMode>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUCullMode'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUCullModeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUBlendFactor {
    Zero,
    One,
    Src,
    One_minus_src,
    Src_alpha,
    One_minus_src_alpha,
    Dst,
    One_minus_dst,
    Dst_alpha,
    One_minus_dst_alpha,
    Src_alpha_saturated,
    Constant,
    One_minus_constant
}
pub mod GPUBlendFactorValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUBlendFactor)] = &[
        ("zero", super::GPUBlendFactor::Zero),
        ("one", super::GPUBlendFactor::One),
        ("src", super::GPUBlendFactor::Src),
        ("one-minus-src", super::GPUBlendFactor::One_minus_src),
        ("src-alpha", super::GPUBlendFactor::Src_alpha),
        ("one-minus-src-alpha", super::GPUBlendFactor::One_minus_src_alpha),
        ("dst", super::GPUBlendFactor::Dst),
        ("one-minus-dst", super::GPUBlendFactor::One_minus_dst),
        ("dst-alpha", super::GPUBlendFactor::Dst_alpha),
        ("one-minus-dst-alpha", super::GPUBlendFactor::One_minus_dst_alpha),
        ("src-alpha-saturated", super::GPUBlendFactor::Src_alpha_saturated),
        ("constant", super::GPUBlendFactor::Constant),
        ("one-minus-constant", super::GPUBlendFactor::One_minus_constant),
    ];

    impl super::GPUBlendFactor {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUBlendFactor {
        fn default() -> super::GPUBlendFactor {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUBlendFactor {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUBlendFactor {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUBlendFactor {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUBlendFactor>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUBlendFactor'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUBlendFactorValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUBlendOperation {
    Add,
    Subtract,
    Reverse_subtract,
    Min,
    Max
}
pub mod GPUBlendOperationValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUBlendOperation)] = &[
        ("add", super::GPUBlendOperation::Add),
        ("subtract", super::GPUBlendOperation::Subtract),
        ("reverse-subtract", super::GPUBlendOperation::Reverse_subtract),
        ("min", super::GPUBlendOperation::Min),
        ("max", super::GPUBlendOperation::Max),
    ];

    impl super::GPUBlendOperation {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUBlendOperation {
        fn default() -> super::GPUBlendOperation {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUBlendOperation {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUBlendOperation {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUBlendOperation {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUBlendOperation>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUBlendOperation'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUBlendOperationValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUStencilOperation {
    Keep,
    Zero,
    Replace,
    Invert,
    Increment_clamp,
    Decrement_clamp,
    Increment_wrap,
    Decrement_wrap
}
pub mod GPUStencilOperationValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUStencilOperation)] = &[
        ("keep", super::GPUStencilOperation::Keep),
        ("zero", super::GPUStencilOperation::Zero),
        ("replace", super::GPUStencilOperation::Replace),
        ("invert", super::GPUStencilOperation::Invert),
        ("increment-clamp", super::GPUStencilOperation::Increment_clamp),
        ("decrement-clamp", super::GPUStencilOperation::Decrement_clamp),
        ("increment-wrap", super::GPUStencilOperation::Increment_wrap),
        ("decrement-wrap", super::GPUStencilOperation::Decrement_wrap),
    ];

    impl super::GPUStencilOperation {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUStencilOperation {
        fn default() -> super::GPUStencilOperation {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUStencilOperation {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUStencilOperation {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUStencilOperation {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUStencilOperation>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUStencilOperation'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUStencilOperationValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUIndexFormat {
    Uint16,
    Uint32
}
pub mod GPUIndexFormatValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUIndexFormat)] = &[
        ("uint16", super::GPUIndexFormat::Uint16),
        ("uint32", super::GPUIndexFormat::Uint32),
    ];

    impl super::GPUIndexFormat {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUIndexFormat {
        fn default() -> super::GPUIndexFormat {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUIndexFormat {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUIndexFormat {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUIndexFormat {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUIndexFormat>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUIndexFormat'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUIndexFormatValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUVertexFormat {
    Uint8x2,
    Uint8x4,
    Sint8x2,
    Sint8x4,
    Unorm8x2,
    Unorm8x4,
    Snorm8x2,
    Snorm8x4,
    Uint16x2,
    Uint16x4,
    Sint16x2,
    Sint16x4,
    Unorm16x2,
    Unorm16x4,
    Snorm16x2,
    Snorm16x4,
    Float16x2,
    Float16x4,
    Float32,
    Float32x2,
    Float32x3,
    Float32x4,
    Uint32,
    Uint32x2,
    Uint32x3,
    Uint32x4,
    Sint32,
    Sint32x2,
    Sint32x3,
    Sint32x4
}
pub mod GPUVertexFormatValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUVertexFormat)] = &[
        ("uint8x2", super::GPUVertexFormat::Uint8x2),
        ("uint8x4", super::GPUVertexFormat::Uint8x4),
        ("sint8x2", super::GPUVertexFormat::Sint8x2),
        ("sint8x4", super::GPUVertexFormat::Sint8x4),
        ("unorm8x2", super::GPUVertexFormat::Unorm8x2),
        ("unorm8x4", super::GPUVertexFormat::Unorm8x4),
        ("snorm8x2", super::GPUVertexFormat::Snorm8x2),
        ("snorm8x4", super::GPUVertexFormat::Snorm8x4),
        ("uint16x2", super::GPUVertexFormat::Uint16x2),
        ("uint16x4", super::GPUVertexFormat::Uint16x4),
        ("sint16x2", super::GPUVertexFormat::Sint16x2),
        ("sint16x4", super::GPUVertexFormat::Sint16x4),
        ("unorm16x2", super::GPUVertexFormat::Unorm16x2),
        ("unorm16x4", super::GPUVertexFormat::Unorm16x4),
        ("snorm16x2", super::GPUVertexFormat::Snorm16x2),
        ("snorm16x4", super::GPUVertexFormat::Snorm16x4),
        ("float16x2", super::GPUVertexFormat::Float16x2),
        ("float16x4", super::GPUVertexFormat::Float16x4),
        ("float32", super::GPUVertexFormat::Float32),
        ("float32x2", super::GPUVertexFormat::Float32x2),
        ("float32x3", super::GPUVertexFormat::Float32x3),
        ("float32x4", super::GPUVertexFormat::Float32x4),
        ("uint32", super::GPUVertexFormat::Uint32),
        ("uint32x2", super::GPUVertexFormat::Uint32x2),
        ("uint32x3", super::GPUVertexFormat::Uint32x3),
        ("uint32x4", super::GPUVertexFormat::Uint32x4),
        ("sint32", super::GPUVertexFormat::Sint32),
        ("sint32x2", super::GPUVertexFormat::Sint32x2),
        ("sint32x3", super::GPUVertexFormat::Sint32x3),
        ("sint32x4", super::GPUVertexFormat::Sint32x4),
    ];

    impl super::GPUVertexFormat {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUVertexFormat {
        fn default() -> super::GPUVertexFormat {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUVertexFormat {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUVertexFormat {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUVertexFormat {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUVertexFormat>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUVertexFormat'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUVertexFormatValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUVertexStepMode {
    Vertex,
    Instance
}
pub mod GPUVertexStepModeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUVertexStepMode)] = &[
        ("vertex", super::GPUVertexStepMode::Vertex),
        ("instance", super::GPUVertexStepMode::Instance),
    ];

    impl super::GPUVertexStepMode {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUVertexStepMode {
        fn default() -> super::GPUVertexStepMode {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUVertexStepMode {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUVertexStepMode {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUVertexStepMode {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUVertexStepMode>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUVertexStepMode'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUVertexStepModeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPULoadOp {
    Load,
    Clear
}
pub mod GPULoadOpValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPULoadOp)] = &[
        ("load", super::GPULoadOp::Load),
        ("clear", super::GPULoadOp::Clear),
    ];

    impl super::GPULoadOp {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPULoadOp {
        fn default() -> super::GPULoadOp {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPULoadOp {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPULoadOp {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPULoadOp {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPULoadOp>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPULoadOp'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPULoadOpValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUStoreOp {
    Store,
    Discard
}
pub mod GPUStoreOpValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUStoreOp)] = &[
        ("store", super::GPUStoreOp::Store),
        ("discard", super::GPUStoreOp::Discard),
    ];

    impl super::GPUStoreOp {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUStoreOp {
        fn default() -> super::GPUStoreOp {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUStoreOp {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUStoreOp {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUStoreOp {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUStoreOp>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUStoreOp'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUStoreOpValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUPipelineStatisticName {
    Vertex_shader_invocations,
    Clipper_invocations,
    Clipper_primitives_out,
    Fragment_shader_invocations,
    Compute_shader_invocations
}
pub mod GPUPipelineStatisticNameValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUPipelineStatisticName)] = &[
        ("vertex-shader-invocations", super::GPUPipelineStatisticName::Vertex_shader_invocations),
        ("clipper-invocations", super::GPUPipelineStatisticName::Clipper_invocations),
        ("clipper-primitives-out", super::GPUPipelineStatisticName::Clipper_primitives_out),
        ("fragment-shader-invocations", super::GPUPipelineStatisticName::Fragment_shader_invocations),
        ("compute-shader-invocations", super::GPUPipelineStatisticName::Compute_shader_invocations),
    ];

    impl super::GPUPipelineStatisticName {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUPipelineStatisticName {
        fn default() -> super::GPUPipelineStatisticName {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUPipelineStatisticName {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUPipelineStatisticName {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUPipelineStatisticName {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUPipelineStatisticName>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUPipelineStatisticName'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUPipelineStatisticNameValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUQueryType {
    Occlusion,
    Pipeline_statistics,
    Timestamp
}
pub mod GPUQueryTypeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUQueryType)] = &[
        ("occlusion", super::GPUQueryType::Occlusion),
        ("pipeline-statistics", super::GPUQueryType::Pipeline_statistics),
        ("timestamp", super::GPUQueryType::Timestamp),
    ];

    impl super::GPUQueryType {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUQueryType {
        fn default() -> super::GPUQueryType {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUQueryType {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUQueryType {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUQueryType {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUQueryType>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUQueryType'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUQueryTypeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUCanvasAlphaMode {
    Opaque,
    Premultiplied
}
pub mod GPUCanvasAlphaModeValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUCanvasAlphaMode)] = &[
        ("opaque", super::GPUCanvasAlphaMode::Opaque),
        ("premultiplied", super::GPUCanvasAlphaMode::Premultiplied),
    ];

    impl super::GPUCanvasAlphaMode {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUCanvasAlphaMode {
        fn default() -> super::GPUCanvasAlphaMode {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUCanvasAlphaMode {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUCanvasAlphaMode {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUCanvasAlphaMode {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUCanvasAlphaMode>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUCanvasAlphaMode'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUCanvasAlphaModeValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUDeviceLostReason {
    Unknown,
    Destroyed
}
pub mod GPUDeviceLostReasonValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUDeviceLostReason)] = &[
        ("unknown", super::GPUDeviceLostReason::Unknown),
        ("destroyed", super::GPUDeviceLostReason::Destroyed),
    ];

    impl super::GPUDeviceLostReason {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUDeviceLostReason {
        fn default() -> super::GPUDeviceLostReason {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUDeviceLostReason {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUDeviceLostReason {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUDeviceLostReason {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUDeviceLostReason>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUDeviceLostReason'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUDeviceLostReasonValues


#[repr(usize)]
#[derive(Copy, Clone, Debug, JSTraceable, MallocSizeOf, PartialEq)]
pub enum GPUErrorFilter {
    Validation,
    Out_of_memory,
    Internal
}
pub mod GPUErrorFilterValues {

    use crate::utils::find_enum_value;
    use js::conversions::ConversionResult;
    use js::conversions::FromJSValConvertible;
    use js::conversions::ToJSValConvertible;
    use js::context::RawJSContext;
    use js::rust::HandleValue;
    use js::rust::MutableHandleValue;
    use js::jsval::JSVal;

    pub(crate) const pairs: &[(&str, super::GPUErrorFilter)] = &[
        ("validation", super::GPUErrorFilter::Validation),
        ("out-of-memory", super::GPUErrorFilter::Out_of_memory),
        ("internal", super::GPUErrorFilter::Internal),
    ];

    impl super::GPUErrorFilter {
        pub fn as_str(&self) -> &'static str {
            pairs[*self as usize].0
        }
    }

    impl Default for super::GPUErrorFilter {
        fn default() -> super::GPUErrorFilter {
            pairs[0].1
        }
    }

    impl std::str::FromStr for super::GPUErrorFilter {
        type Err = ();

        fn from_str(s: &str) -> Result<Self, Self::Err> {
            pairs
                .iter()
                .find(|&&(key, _)| s == key)
                .map(|&(_, ev)| ev)
                .ok_or(())
        }
    }

    impl ToJSValConvertible for super::GPUErrorFilter {
        unsafe fn to_jsval(&self, cx: *mut RawJSContext, rval: MutableHandleValue) {
            pairs[*self as usize].0.to_jsval(cx, rval);
        }
    }

    impl FromJSValConvertible for super::GPUErrorFilter {
        type Config = ();
        unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                             -> Result<ConversionResult<super::GPUErrorFilter>, ()> {
            match find_enum_value(cx, value, pairs) {
                Err(_) => Err(()),
                Ok((None, search)) => {
                    Ok(ConversionResult::Failure(
                        format!("'{}' is not a valid enum value for enumeration 'GPUErrorFilter'.", search).into()
                    ))
                }
                Ok((Some(&value), _)) => Ok(ConversionResult::Success(value)),
            }
        }
    }
        } // mod GPUErrorFilterValues

pub type GPUBufferUsageFlags = u32;

pub type GPUMapModeFlags = u32;

pub type GPUTextureUsageFlags = u32;

pub type GPUShaderStageFlags = u32;

pub use self::GenericUnionTypes::GPUSamplerOrGPUTextureViewOrGPUBufferBinding as GPUBindingResource;

pub type GPUPipelineConstantValue = Finite<f64>;

pub type GPUColorWriteFlags = u32;

pub type GPUBufferDynamicOffset = u32;

pub type GPUStencilValue = u32;

pub type GPUSampleMask = u32;

pub type GPUDepthBias = i32;

pub type GPUSize64 = u64;

pub type GPUIntegerCoordinate = u32;

pub type GPUIndex32 = u32;

pub type GPUSize32 = u32;

pub type GPUSignedOffset32 = i32;

pub type GPUSize64Out = u64;

pub type GPUIntegerCoordinateOut = u32;

pub type GPUSize32Out = u32;

pub type GPUFlagsConstant = u32;

pub use self::GenericUnionTypes::DoubleSequenceOrGPUColorDict as GPUColor;

pub use self::GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict as GPUOrigin2D;

pub use self::GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict as GPUOrigin3D;

pub use self::GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict as GPUExtent3D;

#[derive(JSTraceable, MallocSizeOf)]
pub struct GPUObjectDescriptorBase {
    pub label: USVString,
}
impl Default for GPUObjectDescriptorBase {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUObjectDescriptorBase {
    pub fn empty() -> Self {
        Self {
                label: USVString("".to_owned()),
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUObjectDescriptorBase>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUObjectDescriptorBase {
                label: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "label", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            USVString("".to_owned())
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUObjectDescriptorBase {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUObjectDescriptorBase>, ()> {
        GPUObjectDescriptorBase::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUObjectDescriptorBase {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let label = &self.label;
        rooted!(in(cx) let mut label_js = UndefinedValue());
        label.to_jsval(cx, label_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "label", label_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUObjectDescriptorBase {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPURequestAdapterOptions {
    pub forceFallbackAdapter: bool,
    pub powerPreference: Option<GPUPowerPreference>,
}
impl Default for GPURequestAdapterOptions {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPURequestAdapterOptions {
    pub fn empty() -> Self {
        Self {
                forceFallbackAdapter: false,
                powerPreference: None,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPURequestAdapterOptions>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPURequestAdapterOptions {
                forceFallbackAdapter: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "forceFallbackAdapter", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                powerPreference: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "powerPreference", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPURequestAdapterOptions {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPURequestAdapterOptions>, ()> {
        GPURequestAdapterOptions::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPURequestAdapterOptions {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let forceFallbackAdapter = &self.forceFallbackAdapter;
        rooted!(in(cx) let mut forceFallbackAdapter_js = UndefinedValue());
        forceFallbackAdapter.to_jsval(cx, forceFallbackAdapter_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "forceFallbackAdapter", forceFallbackAdapter_js.handle()).unwrap();
        if let Some(ref powerPreference) = self.powerPreference {
            rooted!(in(cx) let mut powerPreference_js = UndefinedValue());
            powerPreference.to_jsval(cx, powerPreference_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "powerPreference", powerPreference_js.handle()).unwrap();
        }
    }
}

impl ToJSValConvertible for GPURequestAdapterOptions {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUDeviceDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub requiredFeatures: Vec<GPUFeatureName>,
    pub requiredLimits: Option<Record<DOMString, u64>>,
}
impl Default for GPUDeviceDescriptor {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUDeviceDescriptor {
    pub fn empty() -> Self {
        Self {
                parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::empty(),
                requiredFeatures: Vec::new(),
                requiredLimits: None,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUDeviceDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUDeviceDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                requiredFeatures: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "requiredFeatures", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            Vec::new()
                    }
                },
                requiredLimits: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "requiredLimits", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUDeviceDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUDeviceDescriptor>, ()> {
        GPUDeviceDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUDeviceDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let requiredFeatures = &self.requiredFeatures;
        rooted!(in(cx) let mut requiredFeatures_js = UndefinedValue());
        requiredFeatures.to_jsval(cx, requiredFeatures_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "requiredFeatures", requiredFeatures_js.handle()).unwrap();
        if let Some(ref requiredLimits) = self.requiredLimits {
            rooted!(in(cx) let mut requiredLimits_js = UndefinedValue());
            requiredLimits.to_jsval(cx, requiredLimits_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "requiredLimits", requiredLimits_js.handle()).unwrap();
        }
    }
}

impl ToJSValConvertible for GPUDeviceDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUBufferDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub mappedAtCreation: bool,
    pub size: u64,
    pub usage: u32,
}

impl GPUBufferDescriptor {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUBufferDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUBufferDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                mappedAtCreation: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "mappedAtCreation", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                size: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "size", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"size\".");
                            return Err(());
                    }
                },
                usage: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "usage", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"usage\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUBufferDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUBufferDescriptor>, ()> {
        GPUBufferDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUBufferDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let mappedAtCreation = &self.mappedAtCreation;
        rooted!(in(cx) let mut mappedAtCreation_js = UndefinedValue());
        mappedAtCreation.to_jsval(cx, mappedAtCreation_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "mappedAtCreation", mappedAtCreation_js.handle()).unwrap();
        let size = &self.size;
        rooted!(in(cx) let mut size_js = UndefinedValue());
        size.to_jsval(cx, size_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "size", size_js.handle()).unwrap();
        let usage = &self.usage;
        rooted!(in(cx) let mut usage_js = UndefinedValue());
        usage.to_jsval(cx, usage_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "usage", usage_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUBufferDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable, MallocSizeOf)]
pub struct GPUTextureDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub dimension: GPUTextureDimension,
    pub format: GPUTextureFormat,
    pub mipLevelCount: u32,
    pub sampleCount: u32,
    pub size: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict,
    pub usage: u32,
    pub viewFormats: Vec<GPUTextureFormat>,
}

impl GPUTextureDescriptor {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUTextureDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUTextureDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                dimension: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "dimension", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUTextureDimension::_2d
                    }
                },
                format: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "format", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"format\".");
                            return Err(());
                    }
                },
                mipLevelCount: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "mipLevelCount", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            1
                    }
                },
                sampleCount: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "sampleCount", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            1
                    }
                },
                size: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "size", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"size\".");
                            return Err(());
                    }
                },
                usage: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "usage", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"usage\".");
                            return Err(());
                    }
                },
                viewFormats: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "viewFormats", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            Vec::new()
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUTextureDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUTextureDescriptor>, ()> {
        GPUTextureDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUTextureDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let dimension = &self.dimension;
        rooted!(in(cx) let mut dimension_js = UndefinedValue());
        dimension.to_jsval(cx, dimension_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "dimension", dimension_js.handle()).unwrap();
        let format = &self.format;
        rooted!(in(cx) let mut format_js = UndefinedValue());
        format.to_jsval(cx, format_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "format", format_js.handle()).unwrap();
        let mipLevelCount = &self.mipLevelCount;
        rooted!(in(cx) let mut mipLevelCount_js = UndefinedValue());
        mipLevelCount.to_jsval(cx, mipLevelCount_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "mipLevelCount", mipLevelCount_js.handle()).unwrap();
        let sampleCount = &self.sampleCount;
        rooted!(in(cx) let mut sampleCount_js = UndefinedValue());
        sampleCount.to_jsval(cx, sampleCount_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "sampleCount", sampleCount_js.handle()).unwrap();
        let size = &self.size;
        rooted!(in(cx) let mut size_js = UndefinedValue());
        size.to_jsval(cx, size_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "size", size_js.handle()).unwrap();
        let usage = &self.usage;
        rooted!(in(cx) let mut usage_js = UndefinedValue());
        usage.to_jsval(cx, usage_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "usage", usage_js.handle()).unwrap();
        let viewFormats = &self.viewFormats;
        rooted!(in(cx) let mut viewFormats_js = UndefinedValue());
        viewFormats.to_jsval(cx, viewFormats_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "viewFormats", viewFormats_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUTextureDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUTextureViewDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub arrayLayerCount: Option<u32>,
    pub aspect: GPUTextureAspect,
    pub baseArrayLayer: u32,
    pub baseMipLevel: u32,
    pub dimension: Option<GPUTextureViewDimension>,
    pub format: Option<GPUTextureFormat>,
    pub mipLevelCount: Option<u32>,
    pub usage: u32,
}
impl Default for GPUTextureViewDescriptor {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUTextureViewDescriptor {
    pub fn empty() -> Self {
        Self {
                parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::empty(),
                arrayLayerCount: None,
                aspect: GPUTextureAspect::All,
                baseArrayLayer: 0,
                baseMipLevel: 0,
                dimension: None,
                format: None,
                mipLevelCount: None,
                usage: 0,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUTextureViewDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUTextureViewDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                arrayLayerCount: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "arrayLayerCount", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                aspect: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "aspect", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUTextureAspect::All
                    }
                },
                baseArrayLayer: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "baseArrayLayer", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                baseMipLevel: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "baseMipLevel", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                dimension: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "dimension", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                format: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "format", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                mipLevelCount: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "mipLevelCount", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                usage: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "usage", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUTextureViewDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUTextureViewDescriptor>, ()> {
        GPUTextureViewDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUTextureViewDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        if let Some(ref arrayLayerCount) = self.arrayLayerCount {
            rooted!(in(cx) let mut arrayLayerCount_js = UndefinedValue());
            arrayLayerCount.to_jsval(cx, arrayLayerCount_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "arrayLayerCount", arrayLayerCount_js.handle()).unwrap();
        }
        let aspect = &self.aspect;
        rooted!(in(cx) let mut aspect_js = UndefinedValue());
        aspect.to_jsval(cx, aspect_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "aspect", aspect_js.handle()).unwrap();
        let baseArrayLayer = &self.baseArrayLayer;
        rooted!(in(cx) let mut baseArrayLayer_js = UndefinedValue());
        baseArrayLayer.to_jsval(cx, baseArrayLayer_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "baseArrayLayer", baseArrayLayer_js.handle()).unwrap();
        let baseMipLevel = &self.baseMipLevel;
        rooted!(in(cx) let mut baseMipLevel_js = UndefinedValue());
        baseMipLevel.to_jsval(cx, baseMipLevel_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "baseMipLevel", baseMipLevel_js.handle()).unwrap();
        if let Some(ref dimension) = self.dimension {
            rooted!(in(cx) let mut dimension_js = UndefinedValue());
            dimension.to_jsval(cx, dimension_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "dimension", dimension_js.handle()).unwrap();
        }
        if let Some(ref format) = self.format {
            rooted!(in(cx) let mut format_js = UndefinedValue());
            format.to_jsval(cx, format_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "format", format_js.handle()).unwrap();
        }
        if let Some(ref mipLevelCount) = self.mipLevelCount {
            rooted!(in(cx) let mut mipLevelCount_js = UndefinedValue());
            mipLevelCount.to_jsval(cx, mipLevelCount_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "mipLevelCount", mipLevelCount_js.handle()).unwrap();
        }
        let usage = &self.usage;
        rooted!(in(cx) let mut usage_js = UndefinedValue());
        usage.to_jsval(cx, usage_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "usage", usage_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUTextureViewDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUSamplerDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub addressModeU: GPUAddressMode,
    pub addressModeV: GPUAddressMode,
    pub addressModeW: GPUAddressMode,
    pub compare: Option<GPUCompareFunction>,
    pub lodMaxClamp: Finite<f32>,
    pub lodMinClamp: Finite<f32>,
    pub magFilter: GPUFilterMode,
    pub maxAnisotropy: u16,
    pub minFilter: GPUFilterMode,
    pub mipmapFilter: GPUFilterMode,
}
impl Default for GPUSamplerDescriptor {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUSamplerDescriptor {
    pub fn empty() -> Self {
        Self {
                parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::empty(),
                addressModeU: GPUAddressMode::Clamp_to_edge,
                addressModeV: GPUAddressMode::Clamp_to_edge,
                addressModeW: GPUAddressMode::Clamp_to_edge,
                compare: None,
                lodMaxClamp: Finite::wrap(1000.0),
                lodMinClamp: Finite::wrap(0.0),
                magFilter: GPUFilterMode::Nearest,
                maxAnisotropy: 1,
                minFilter: GPUFilterMode::Nearest,
                mipmapFilter: GPUFilterMode::Nearest,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUSamplerDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUSamplerDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                addressModeU: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "addressModeU", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUAddressMode::Clamp_to_edge
                    }
                },
                addressModeV: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "addressModeV", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUAddressMode::Clamp_to_edge
                    }
                },
                addressModeW: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "addressModeW", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUAddressMode::Clamp_to_edge
                    }
                },
                compare: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "compare", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                lodMaxClamp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "lodMaxClamp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            Finite::wrap(1000.0)
                    }
                },
                lodMinClamp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "lodMinClamp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            Finite::wrap(0.0)
                    }
                },
                magFilter: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "magFilter", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUFilterMode::Nearest
                    }
                },
                maxAnisotropy: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "maxAnisotropy", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::Clamp) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            1
                    }
                },
                minFilter: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "minFilter", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUFilterMode::Nearest
                    }
                },
                mipmapFilter: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "mipmapFilter", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUFilterMode::Nearest
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUSamplerDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUSamplerDescriptor>, ()> {
        GPUSamplerDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUSamplerDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let addressModeU = &self.addressModeU;
        rooted!(in(cx) let mut addressModeU_js = UndefinedValue());
        addressModeU.to_jsval(cx, addressModeU_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "addressModeU", addressModeU_js.handle()).unwrap();
        let addressModeV = &self.addressModeV;
        rooted!(in(cx) let mut addressModeV_js = UndefinedValue());
        addressModeV.to_jsval(cx, addressModeV_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "addressModeV", addressModeV_js.handle()).unwrap();
        let addressModeW = &self.addressModeW;
        rooted!(in(cx) let mut addressModeW_js = UndefinedValue());
        addressModeW.to_jsval(cx, addressModeW_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "addressModeW", addressModeW_js.handle()).unwrap();
        if let Some(ref compare) = self.compare {
            rooted!(in(cx) let mut compare_js = UndefinedValue());
            compare.to_jsval(cx, compare_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "compare", compare_js.handle()).unwrap();
        }
        let lodMaxClamp = &self.lodMaxClamp;
        rooted!(in(cx) let mut lodMaxClamp_js = UndefinedValue());
        lodMaxClamp.to_jsval(cx, lodMaxClamp_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "lodMaxClamp", lodMaxClamp_js.handle()).unwrap();
        let lodMinClamp = &self.lodMinClamp;
        rooted!(in(cx) let mut lodMinClamp_js = UndefinedValue());
        lodMinClamp.to_jsval(cx, lodMinClamp_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "lodMinClamp", lodMinClamp_js.handle()).unwrap();
        let magFilter = &self.magFilter;
        rooted!(in(cx) let mut magFilter_js = UndefinedValue());
        magFilter.to_jsval(cx, magFilter_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "magFilter", magFilter_js.handle()).unwrap();
        let maxAnisotropy = &self.maxAnisotropy;
        rooted!(in(cx) let mut maxAnisotropy_js = UndefinedValue());
        maxAnisotropy.to_jsval(cx, maxAnisotropy_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "maxAnisotropy", maxAnisotropy_js.handle()).unwrap();
        let minFilter = &self.minFilter;
        rooted!(in(cx) let mut minFilter_js = UndefinedValue());
        minFilter.to_jsval(cx, minFilter_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "minFilter", minFilter_js.handle()).unwrap();
        let mipmapFilter = &self.mipmapFilter;
        rooted!(in(cx) let mut mipmapFilter_js = UndefinedValue());
        mipmapFilter.to_jsval(cx, mipmapFilter_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "mipmapFilter", mipmapFilter_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUSamplerDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUBindGroupLayoutDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub entries: Vec<crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupLayoutEntry>,
}

impl GPUBindGroupLayoutDescriptor {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUBindGroupLayoutDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUBindGroupLayoutDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                entries: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "entries", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"entries\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUBindGroupLayoutDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUBindGroupLayoutDescriptor>, ()> {
        GPUBindGroupLayoutDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUBindGroupLayoutDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let entries = &self.entries;
        rooted!(in(cx) let mut entries_js = UndefinedValue());
        entries.to_jsval(cx, entries_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "entries", entries_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUBindGroupLayoutDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUBindGroupLayoutEntry {
    pub binding: u32,
    pub buffer: Option<crate::codegen::GenericBindings::WebGPUBinding::GPUBufferBindingLayout>,
    pub externalTexture: Option<crate::codegen::GenericBindings::WebGPUBinding::GPUExternalTextureBindingLayout>,
    pub sampler: Option<crate::codegen::GenericBindings::WebGPUBinding::GPUSamplerBindingLayout>,
    pub storageTexture: Option<crate::codegen::GenericBindings::WebGPUBinding::GPUStorageTextureBindingLayout>,
    pub texture: Option<crate::codegen::GenericBindings::WebGPUBinding::GPUTextureBindingLayout>,
    pub visibility: u32,
}

impl GPUBindGroupLayoutEntry {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUBindGroupLayoutEntry>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUBindGroupLayoutEntry {
                binding: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "binding", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"binding\".");
                            return Err(());
                    }
                },
                buffer: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "buffer", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                externalTexture: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "externalTexture", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                sampler: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "sampler", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                storageTexture: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "storageTexture", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                texture: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "texture", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                visibility: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "visibility", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"visibility\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUBindGroupLayoutEntry {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUBindGroupLayoutEntry>, ()> {
        GPUBindGroupLayoutEntry::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUBindGroupLayoutEntry {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let binding = &self.binding;
        rooted!(in(cx) let mut binding_js = UndefinedValue());
        binding.to_jsval(cx, binding_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "binding", binding_js.handle()).unwrap();
        if let Some(ref buffer) = self.buffer {
            rooted!(in(cx) let mut buffer_js = UndefinedValue());
            buffer.to_jsval(cx, buffer_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "buffer", buffer_js.handle()).unwrap();
        }
        if let Some(ref externalTexture) = self.externalTexture {
            rooted!(in(cx) let mut externalTexture_js = UndefinedValue());
            externalTexture.to_jsval(cx, externalTexture_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "externalTexture", externalTexture_js.handle()).unwrap();
        }
        if let Some(ref sampler) = self.sampler {
            rooted!(in(cx) let mut sampler_js = UndefinedValue());
            sampler.to_jsval(cx, sampler_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "sampler", sampler_js.handle()).unwrap();
        }
        if let Some(ref storageTexture) = self.storageTexture {
            rooted!(in(cx) let mut storageTexture_js = UndefinedValue());
            storageTexture.to_jsval(cx, storageTexture_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "storageTexture", storageTexture_js.handle()).unwrap();
        }
        if let Some(ref texture) = self.texture {
            rooted!(in(cx) let mut texture_js = UndefinedValue());
            texture.to_jsval(cx, texture_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "texture", texture_js.handle()).unwrap();
        }
        let visibility = &self.visibility;
        rooted!(in(cx) let mut visibility_js = UndefinedValue());
        visibility.to_jsval(cx, visibility_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "visibility", visibility_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUBindGroupLayoutEntry {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUBufferBindingLayout {
    pub hasDynamicOffset: bool,
    pub minBindingSize: u64,
    pub type_: GPUBufferBindingType,
}
impl Default for GPUBufferBindingLayout {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUBufferBindingLayout {
    pub fn empty() -> Self {
        Self {
                hasDynamicOffset: false,
                minBindingSize: 0,
                type_: GPUBufferBindingType::Uniform,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUBufferBindingLayout>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUBufferBindingLayout {
                hasDynamicOffset: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "hasDynamicOffset", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                minBindingSize: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "minBindingSize", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                type_: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "type", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUBufferBindingType::Uniform
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUBufferBindingLayout {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUBufferBindingLayout>, ()> {
        GPUBufferBindingLayout::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUBufferBindingLayout {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let hasDynamicOffset = &self.hasDynamicOffset;
        rooted!(in(cx) let mut hasDynamicOffset_js = UndefinedValue());
        hasDynamicOffset.to_jsval(cx, hasDynamicOffset_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "hasDynamicOffset", hasDynamicOffset_js.handle()).unwrap();
        let minBindingSize = &self.minBindingSize;
        rooted!(in(cx) let mut minBindingSize_js = UndefinedValue());
        minBindingSize.to_jsval(cx, minBindingSize_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "minBindingSize", minBindingSize_js.handle()).unwrap();
        let type_ = &self.type_;
        rooted!(in(cx) let mut type__js = UndefinedValue());
        type_.to_jsval(cx, type__js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "type", type__js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUBufferBindingLayout {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUSamplerBindingLayout {
    pub type_: GPUSamplerBindingType,
}
impl Default for GPUSamplerBindingLayout {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUSamplerBindingLayout {
    pub fn empty() -> Self {
        Self {
                type_: GPUSamplerBindingType::Filtering,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUSamplerBindingLayout>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUSamplerBindingLayout {
                type_: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "type", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUSamplerBindingType::Filtering
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUSamplerBindingLayout {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUSamplerBindingLayout>, ()> {
        GPUSamplerBindingLayout::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUSamplerBindingLayout {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let type_ = &self.type_;
        rooted!(in(cx) let mut type__js = UndefinedValue());
        type_.to_jsval(cx, type__js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "type", type__js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUSamplerBindingLayout {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUTextureBindingLayout {
    pub multisampled: bool,
    pub sampleType: GPUTextureSampleType,
    pub viewDimension: GPUTextureViewDimension,
}
impl Default for GPUTextureBindingLayout {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUTextureBindingLayout {
    pub fn empty() -> Self {
        Self {
                multisampled: false,
                sampleType: GPUTextureSampleType::Float,
                viewDimension: GPUTextureViewDimension::_2d,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUTextureBindingLayout>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUTextureBindingLayout {
                multisampled: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "multisampled", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                sampleType: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "sampleType", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUTextureSampleType::Float
                    }
                },
                viewDimension: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "viewDimension", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUTextureViewDimension::_2d
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUTextureBindingLayout {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUTextureBindingLayout>, ()> {
        GPUTextureBindingLayout::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUTextureBindingLayout {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let multisampled = &self.multisampled;
        rooted!(in(cx) let mut multisampled_js = UndefinedValue());
        multisampled.to_jsval(cx, multisampled_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "multisampled", multisampled_js.handle()).unwrap();
        let sampleType = &self.sampleType;
        rooted!(in(cx) let mut sampleType_js = UndefinedValue());
        sampleType.to_jsval(cx, sampleType_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "sampleType", sampleType_js.handle()).unwrap();
        let viewDimension = &self.viewDimension;
        rooted!(in(cx) let mut viewDimension_js = UndefinedValue());
        viewDimension.to_jsval(cx, viewDimension_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "viewDimension", viewDimension_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUTextureBindingLayout {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUStorageTextureBindingLayout {
    pub access: GPUStorageTextureAccess,
    pub format: GPUTextureFormat,
    pub viewDimension: GPUTextureViewDimension,
}

impl GPUStorageTextureBindingLayout {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUStorageTextureBindingLayout>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUStorageTextureBindingLayout {
                access: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "access", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUStorageTextureAccess::Write_only
                    }
                },
                format: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "format", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"format\".");
                            return Err(());
                    }
                },
                viewDimension: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "viewDimension", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUTextureViewDimension::_2d
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUStorageTextureBindingLayout {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUStorageTextureBindingLayout>, ()> {
        GPUStorageTextureBindingLayout::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUStorageTextureBindingLayout {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let access = &self.access;
        rooted!(in(cx) let mut access_js = UndefinedValue());
        access.to_jsval(cx, access_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "access", access_js.handle()).unwrap();
        let format = &self.format;
        rooted!(in(cx) let mut format_js = UndefinedValue());
        format.to_jsval(cx, format_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "format", format_js.handle()).unwrap();
        let viewDimension = &self.viewDimension;
        rooted!(in(cx) let mut viewDimension_js = UndefinedValue());
        viewDimension.to_jsval(cx, viewDimension_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "viewDimension", viewDimension_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUStorageTextureBindingLayout {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUExternalTextureBindingLayout {

}
impl Default for GPUExternalTextureBindingLayout {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUExternalTextureBindingLayout {
    pub fn empty() -> Self {
        Self {
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUExternalTextureBindingLayout>, ()> {
         {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUExternalTextureBindingLayout {
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUExternalTextureBindingLayout {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUExternalTextureBindingLayout>, ()> {
        GPUExternalTextureBindingLayout::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUExternalTextureBindingLayout {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
    }
}

impl ToJSValConvertible for GPUExternalTextureBindingLayout {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUBindGroupDescriptor<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub entries: Vec<crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupEntry<D>>,
    pub layout: DomRoot<D::GPUBindGroupLayout>,
}

impl<D: DomTypes> GPUBindGroupDescriptor<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUBindGroupDescriptor<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUBindGroupDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                entries: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "entries", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"entries\".");
                            return Err(());
                    }
                },
                layout: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "layout", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUBindGroupLayout.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            }
                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"layout\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUBindGroupDescriptor<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUBindGroupDescriptor<D>>, ()> {
        GPUBindGroupDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUBindGroupDescriptor<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let entries = &self.entries;
        rooted!(in(cx) let mut entries_js = UndefinedValue());
        entries.to_jsval(cx, entries_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "entries", entries_js.handle()).unwrap();
        let layout = &self.layout;
        rooted!(in(cx) let mut layout_js = UndefinedValue());
        layout.to_jsval(cx, layout_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "layout", layout_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUBindGroupDescriptor<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUBindGroupEntry<D: DomTypes> {
    pub binding: u32,
    pub resource: GenericUnionTypes::GPUSamplerOrGPUTextureViewOrGPUBufferBinding::<D>,
}

impl<D: DomTypes> GPUBindGroupEntry<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUBindGroupEntry<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUBindGroupEntry {
                binding: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "binding", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"binding\".");
                            return Err(());
                    }
                },
                resource: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "resource", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"resource\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUBindGroupEntry<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUBindGroupEntry<D>>, ()> {
        GPUBindGroupEntry::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUBindGroupEntry<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let binding = &self.binding;
        rooted!(in(cx) let mut binding_js = UndefinedValue());
        binding.to_jsval(cx, binding_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "binding", binding_js.handle()).unwrap();
        let resource = &self.resource;
        rooted!(in(cx) let mut resource_js = UndefinedValue());
        resource.to_jsval(cx, resource_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "resource", resource_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUBindGroupEntry<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUBufferBinding<D: DomTypes> {
    pub buffer: DomRoot<D::GPUBuffer>,
    pub offset: u64,
    pub size: Option<u64>,
}

impl<D: DomTypes> GPUBufferBinding<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUBufferBinding<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUBufferBinding {
                buffer: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "buffer", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            }
                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"buffer\".");
                            return Err(());
                    }
                },
                offset: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "offset", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                size: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "size", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUBufferBinding<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUBufferBinding<D>>, ()> {
        GPUBufferBinding::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUBufferBinding<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let buffer = &self.buffer;
        rooted!(in(cx) let mut buffer_js = UndefinedValue());
        buffer.to_jsval(cx, buffer_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "buffer", buffer_js.handle()).unwrap();
        let offset = &self.offset;
        rooted!(in(cx) let mut offset_js = UndefinedValue());
        offset.to_jsval(cx, offset_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "offset", offset_js.handle()).unwrap();
        if let Some(ref size) = self.size {
            rooted!(in(cx) let mut size_js = UndefinedValue());
            size.to_jsval(cx, size_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "size", size_js.handle()).unwrap();
        }
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUBufferBinding<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUPipelineLayoutDescriptor<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub bindGroupLayouts: Vec<DomRoot<D::GPUBindGroupLayout>>,
}

impl<D: DomTypes> GPUPipelineLayoutDescriptor<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUPipelineLayoutDescriptor<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUPipelineLayoutDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                bindGroupLayouts: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "bindGroupLayouts", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"bindGroupLayouts\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUPipelineLayoutDescriptor<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUPipelineLayoutDescriptor<D>>, ()> {
        GPUPipelineLayoutDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUPipelineLayoutDescriptor<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let bindGroupLayouts = &self.bindGroupLayouts;
        rooted!(in(cx) let mut bindGroupLayouts_js = UndefinedValue());
        bindGroupLayouts.to_jsval(cx, bindGroupLayouts_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "bindGroupLayouts", bindGroupLayouts_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUPipelineLayoutDescriptor<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
#[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
pub struct GPUShaderModuleDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub code: USVString,
    pub sourceMap: Option<RootedTraceableBox<Heap<*mut JSObject>>>,
}

impl GPUShaderModuleDescriptor {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<RootedTraceableBox<GPUShaderModuleDescriptor>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = RootedTraceableBox::new(GPUShaderModuleDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                code: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "code", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"code\".");
                            return Err(());
                    }
                },
                sourceMap: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "sourceMap", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(if rval.handle().get().is_object() {
                                RootedTraceableBox::from_box(Heap::boxed(rval.handle().get().to_object()))
                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            })
                    } else {
                            None
                    }
                },
        });
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for RootedTraceableBox<GPUShaderModuleDescriptor> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<RootedTraceableBox<GPUShaderModuleDescriptor>>, ()> {
        GPUShaderModuleDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUShaderModuleDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let code = &self.code;
        rooted!(in(cx) let mut code_js = UndefinedValue());
        code.to_jsval(cx, code_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "code", code_js.handle()).unwrap();
        if let Some(ref sourceMap) = self.sourceMap {
            rooted!(in(cx) let mut sourceMap_js = UndefinedValue());
            sourceMap.to_jsval(cx, sourceMap_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "sourceMap", sourceMap_js.handle()).unwrap();
        }
    }
}

impl ToJSValConvertible for GPUShaderModuleDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUPipelineErrorInit {
    pub reason: GPUPipelineErrorReason,
}

impl GPUPipelineErrorInit {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUPipelineErrorInit>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUPipelineErrorInit {
                reason: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "reason", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"reason\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUPipelineErrorInit {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUPipelineErrorInit>, ()> {
        GPUPipelineErrorInit::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUPipelineErrorInit {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let reason = &self.reason;
        rooted!(in(cx) let mut reason_js = UndefinedValue());
        reason.to_jsval(cx, reason_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "reason", reason_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUPipelineErrorInit {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUPipelineDescriptorBase<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub layout: GenericUnionTypes::GPUPipelineLayoutOrGPUAutoLayoutMode::<D>,
}

impl<D: DomTypes> GPUPipelineDescriptorBase<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUPipelineDescriptorBase<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUPipelineDescriptorBase {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                layout: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "layout", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"layout\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUPipelineDescriptorBase<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUPipelineDescriptorBase<D>>, ()> {
        GPUPipelineDescriptorBase::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUPipelineDescriptorBase<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let layout = &self.layout;
        rooted!(in(cx) let mut layout_js = UndefinedValue());
        layout.to_jsval(cx, layout_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "layout", layout_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUPipelineDescriptorBase<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUProgrammableStage<D: DomTypes> {
    pub constants: Option<Record<USVString, Finite<f64>>>,
    pub entryPoint: Option<USVString>,
    pub module: DomRoot<D::GPUShaderModule>,
}

impl<D: DomTypes> GPUProgrammableStage<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUProgrammableStage<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUProgrammableStage {
                constants: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "constants", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                entryPoint: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "entryPoint", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                module: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "module", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUShaderModule.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            }
                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"module\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUProgrammableStage<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUProgrammableStage<D>>, ()> {
        GPUProgrammableStage::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUProgrammableStage<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        if let Some(ref constants) = self.constants {
            rooted!(in(cx) let mut constants_js = UndefinedValue());
            constants.to_jsval(cx, constants_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "constants", constants_js.handle()).unwrap();
        }
        if let Some(ref entryPoint) = self.entryPoint {
            rooted!(in(cx) let mut entryPoint_js = UndefinedValue());
            entryPoint.to_jsval(cx, entryPoint_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "entryPoint", entryPoint_js.handle()).unwrap();
        }
        let module = &self.module;
        rooted!(in(cx) let mut module_js = UndefinedValue());
        module.to_jsval(cx, module_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "module", module_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUProgrammableStage<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUComputePipelineDescriptor<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineDescriptorBase<D>,
    pub compute: crate::codegen::GenericBindings::WebGPUBinding::GPUProgrammableStage<D>,
}

impl<D: DomTypes> GPUComputePipelineDescriptor<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUComputePipelineDescriptor<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUComputePipelineDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                compute: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "compute", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"compute\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUComputePipelineDescriptor<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUComputePipelineDescriptor<D>>, ()> {
        GPUComputePipelineDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUComputePipelineDescriptor<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let compute = &self.compute;
        rooted!(in(cx) let mut compute_js = UndefinedValue());
        compute.to_jsval(cx, compute_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "compute", compute_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUComputePipelineDescriptor<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPURenderPipelineDescriptor<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineDescriptorBase<D>,
    pub depthStencil: Option<crate::codegen::GenericBindings::WebGPUBinding::GPUDepthStencilState>,
    pub fragment: Option<crate::codegen::GenericBindings::WebGPUBinding::GPUFragmentState<D>>,
    pub multisample: crate::codegen::GenericBindings::WebGPUBinding::GPUMultisampleState,
    pub primitive: crate::codegen::GenericBindings::WebGPUBinding::GPUPrimitiveState,
    pub vertex: crate::codegen::GenericBindings::WebGPUBinding::GPUVertexState<D>,
}

impl<D: DomTypes> GPURenderPipelineDescriptor<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPURenderPipelineDescriptor<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPURenderPipelineDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                depthStencil: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthStencil", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                fragment: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "fragment", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                multisample: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "multisample", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            crate::codegen::GenericBindings::WebGPUBinding::GPUMultisampleState::empty()
                    }
                },
                primitive: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "primitive", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            crate::codegen::GenericBindings::WebGPUBinding::GPUPrimitiveState::empty()
                    }
                },
                vertex: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "vertex", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"vertex\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPURenderPipelineDescriptor<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPURenderPipelineDescriptor<D>>, ()> {
        GPURenderPipelineDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPURenderPipelineDescriptor<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        if let Some(ref depthStencil) = self.depthStencil {
            rooted!(in(cx) let mut depthStencil_js = UndefinedValue());
            depthStencil.to_jsval(cx, depthStencil_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthStencil", depthStencil_js.handle()).unwrap();
        }
        if let Some(ref fragment) = self.fragment {
            rooted!(in(cx) let mut fragment_js = UndefinedValue());
            fragment.to_jsval(cx, fragment_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "fragment", fragment_js.handle()).unwrap();
        }
        let multisample = &self.multisample;
        rooted!(in(cx) let mut multisample_js = UndefinedValue());
        multisample.to_jsval(cx, multisample_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "multisample", multisample_js.handle()).unwrap();
        let primitive = &self.primitive;
        rooted!(in(cx) let mut primitive_js = UndefinedValue());
        primitive.to_jsval(cx, primitive_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "primitive", primitive_js.handle()).unwrap();
        let vertex = &self.vertex;
        rooted!(in(cx) let mut vertex_js = UndefinedValue());
        vertex.to_jsval(cx, vertex_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "vertex", vertex_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPURenderPipelineDescriptor<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUPrimitiveState {
    pub clampDepth: bool,
    pub cullMode: GPUCullMode,
    pub frontFace: GPUFrontFace,
    pub stripIndexFormat: Option<GPUIndexFormat>,
    pub topology: GPUPrimitiveTopology,
}
impl Default for GPUPrimitiveState {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUPrimitiveState {
    pub fn empty() -> Self {
        Self {
                clampDepth: false,
                cullMode: GPUCullMode::None,
                frontFace: GPUFrontFace::Ccw,
                stripIndexFormat: None,
                topology: GPUPrimitiveTopology::Triangle_list,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUPrimitiveState>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUPrimitiveState {
                clampDepth: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "clampDepth", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                cullMode: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "cullMode", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUCullMode::None
                    }
                },
                frontFace: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "frontFace", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUFrontFace::Ccw
                    }
                },
                stripIndexFormat: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stripIndexFormat", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                topology: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "topology", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUPrimitiveTopology::Triangle_list
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUPrimitiveState {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUPrimitiveState>, ()> {
        GPUPrimitiveState::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUPrimitiveState {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let clampDepth = &self.clampDepth;
        rooted!(in(cx) let mut clampDepth_js = UndefinedValue());
        clampDepth.to_jsval(cx, clampDepth_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "clampDepth", clampDepth_js.handle()).unwrap();
        let cullMode = &self.cullMode;
        rooted!(in(cx) let mut cullMode_js = UndefinedValue());
        cullMode.to_jsval(cx, cullMode_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "cullMode", cullMode_js.handle()).unwrap();
        let frontFace = &self.frontFace;
        rooted!(in(cx) let mut frontFace_js = UndefinedValue());
        frontFace.to_jsval(cx, frontFace_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "frontFace", frontFace_js.handle()).unwrap();
        if let Some(ref stripIndexFormat) = self.stripIndexFormat {
            rooted!(in(cx) let mut stripIndexFormat_js = UndefinedValue());
            stripIndexFormat.to_jsval(cx, stripIndexFormat_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stripIndexFormat", stripIndexFormat_js.handle()).unwrap();
        }
        let topology = &self.topology;
        rooted!(in(cx) let mut topology_js = UndefinedValue());
        topology.to_jsval(cx, topology_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "topology", topology_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUPrimitiveState {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUMultisampleState {
    pub alphaToCoverageEnabled: bool,
    pub count: u32,
    pub mask: u32,
}
impl Default for GPUMultisampleState {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUMultisampleState {
    pub fn empty() -> Self {
        Self {
                alphaToCoverageEnabled: false,
                count: 1,
                mask: 4294967295,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUMultisampleState>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUMultisampleState {
                alphaToCoverageEnabled: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "alphaToCoverageEnabled", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                count: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "count", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            1
                    }
                },
                mask: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "mask", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            4294967295
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUMultisampleState {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUMultisampleState>, ()> {
        GPUMultisampleState::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUMultisampleState {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let alphaToCoverageEnabled = &self.alphaToCoverageEnabled;
        rooted!(in(cx) let mut alphaToCoverageEnabled_js = UndefinedValue());
        alphaToCoverageEnabled.to_jsval(cx, alphaToCoverageEnabled_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "alphaToCoverageEnabled", alphaToCoverageEnabled_js.handle()).unwrap();
        let count = &self.count;
        rooted!(in(cx) let mut count_js = UndefinedValue());
        count.to_jsval(cx, count_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "count", count_js.handle()).unwrap();
        let mask = &self.mask;
        rooted!(in(cx) let mut mask_js = UndefinedValue());
        mask.to_jsval(cx, mask_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "mask", mask_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUMultisampleState {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUFragmentState<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUProgrammableStage<D>,
    pub targets: Vec<crate::codegen::GenericBindings::WebGPUBinding::GPUColorTargetState>,
}

impl<D: DomTypes> GPUFragmentState<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUFragmentState<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUFragmentState {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUProgrammableStage::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                targets: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "targets", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"targets\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUFragmentState<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUFragmentState<D>>, ()> {
        GPUFragmentState::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUFragmentState<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let targets = &self.targets;
        rooted!(in(cx) let mut targets_js = UndefinedValue());
        targets.to_jsval(cx, targets_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "targets", targets_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUFragmentState<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUColorTargetState {
    pub blend: Option<crate::codegen::GenericBindings::WebGPUBinding::GPUBlendState>,
    pub format: GPUTextureFormat,
    pub writeMask: u32,
}

impl GPUColorTargetState {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUColorTargetState>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUColorTargetState {
                blend: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "blend", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                format: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "format", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"format\".");
                            return Err(());
                    }
                },
                writeMask: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "writeMask", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            15
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUColorTargetState {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUColorTargetState>, ()> {
        GPUColorTargetState::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUColorTargetState {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        if let Some(ref blend) = self.blend {
            rooted!(in(cx) let mut blend_js = UndefinedValue());
            blend.to_jsval(cx, blend_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "blend", blend_js.handle()).unwrap();
        }
        let format = &self.format;
        rooted!(in(cx) let mut format_js = UndefinedValue());
        format.to_jsval(cx, format_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "format", format_js.handle()).unwrap();
        let writeMask = &self.writeMask;
        rooted!(in(cx) let mut writeMask_js = UndefinedValue());
        writeMask.to_jsval(cx, writeMask_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "writeMask", writeMask_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUColorTargetState {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUBlendState {
    pub alpha: crate::codegen::GenericBindings::WebGPUBinding::GPUBlendComponent,
    pub color: crate::codegen::GenericBindings::WebGPUBinding::GPUBlendComponent,
}

impl GPUBlendState {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUBlendState>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUBlendState {
                alpha: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "alpha", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"alpha\".");
                            return Err(());
                    }
                },
                color: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "color", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"color\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUBlendState {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUBlendState>, ()> {
        GPUBlendState::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUBlendState {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let alpha = &self.alpha;
        rooted!(in(cx) let mut alpha_js = UndefinedValue());
        alpha.to_jsval(cx, alpha_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "alpha", alpha_js.handle()).unwrap();
        let color = &self.color;
        rooted!(in(cx) let mut color_js = UndefinedValue());
        color.to_jsval(cx, color_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "color", color_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUBlendState {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUBlendComponent {
    pub dstFactor: GPUBlendFactor,
    pub operation: GPUBlendOperation,
    pub srcFactor: GPUBlendFactor,
}
impl Default for GPUBlendComponent {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUBlendComponent {
    pub fn empty() -> Self {
        Self {
                dstFactor: GPUBlendFactor::Zero,
                operation: GPUBlendOperation::Add,
                srcFactor: GPUBlendFactor::One,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUBlendComponent>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUBlendComponent {
                dstFactor: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "dstFactor", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUBlendFactor::Zero
                    }
                },
                operation: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "operation", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUBlendOperation::Add
                    }
                },
                srcFactor: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "srcFactor", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUBlendFactor::One
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUBlendComponent {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUBlendComponent>, ()> {
        GPUBlendComponent::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUBlendComponent {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let dstFactor = &self.dstFactor;
        rooted!(in(cx) let mut dstFactor_js = UndefinedValue());
        dstFactor.to_jsval(cx, dstFactor_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "dstFactor", dstFactor_js.handle()).unwrap();
        let operation = &self.operation;
        rooted!(in(cx) let mut operation_js = UndefinedValue());
        operation.to_jsval(cx, operation_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "operation", operation_js.handle()).unwrap();
        let srcFactor = &self.srcFactor;
        rooted!(in(cx) let mut srcFactor_js = UndefinedValue());
        srcFactor.to_jsval(cx, srcFactor_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "srcFactor", srcFactor_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUBlendComponent {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUDepthStencilState {
    pub depthBias: i32,
    pub depthBiasClamp: Finite<f32>,
    pub depthBiasSlopeScale: Finite<f32>,
    pub depthCompare: GPUCompareFunction,
    pub depthWriteEnabled: bool,
    pub format: GPUTextureFormat,
    pub stencilBack: crate::codegen::GenericBindings::WebGPUBinding::GPUStencilFaceState,
    pub stencilFront: crate::codegen::GenericBindings::WebGPUBinding::GPUStencilFaceState,
    pub stencilReadMask: u32,
    pub stencilWriteMask: u32,
}

impl GPUDepthStencilState {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUDepthStencilState>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUDepthStencilState {
                depthBias: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthBias", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                depthBiasClamp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthBiasClamp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            Finite::wrap(0.0)
                    }
                },
                depthBiasSlopeScale: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthBiasSlopeScale", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            Finite::wrap(0.0)
                    }
                },
                depthCompare: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthCompare", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUCompareFunction::Always
                    }
                },
                depthWriteEnabled: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthWriteEnabled", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                format: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "format", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"format\".");
                            return Err(());
                    }
                },
                stencilBack: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stencilBack", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            crate::codegen::GenericBindings::WebGPUBinding::GPUStencilFaceState::empty()
                    }
                },
                stencilFront: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stencilFront", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            crate::codegen::GenericBindings::WebGPUBinding::GPUStencilFaceState::empty()
                    }
                },
                stencilReadMask: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stencilReadMask", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            4294967295
                    }
                },
                stencilWriteMask: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stencilWriteMask", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            4294967295
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUDepthStencilState {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUDepthStencilState>, ()> {
        GPUDepthStencilState::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUDepthStencilState {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let depthBias = &self.depthBias;
        rooted!(in(cx) let mut depthBias_js = UndefinedValue());
        depthBias.to_jsval(cx, depthBias_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthBias", depthBias_js.handle()).unwrap();
        let depthBiasClamp = &self.depthBiasClamp;
        rooted!(in(cx) let mut depthBiasClamp_js = UndefinedValue());
        depthBiasClamp.to_jsval(cx, depthBiasClamp_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthBiasClamp", depthBiasClamp_js.handle()).unwrap();
        let depthBiasSlopeScale = &self.depthBiasSlopeScale;
        rooted!(in(cx) let mut depthBiasSlopeScale_js = UndefinedValue());
        depthBiasSlopeScale.to_jsval(cx, depthBiasSlopeScale_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthBiasSlopeScale", depthBiasSlopeScale_js.handle()).unwrap();
        let depthCompare = &self.depthCompare;
        rooted!(in(cx) let mut depthCompare_js = UndefinedValue());
        depthCompare.to_jsval(cx, depthCompare_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthCompare", depthCompare_js.handle()).unwrap();
        let depthWriteEnabled = &self.depthWriteEnabled;
        rooted!(in(cx) let mut depthWriteEnabled_js = UndefinedValue());
        depthWriteEnabled.to_jsval(cx, depthWriteEnabled_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthWriteEnabled", depthWriteEnabled_js.handle()).unwrap();
        let format = &self.format;
        rooted!(in(cx) let mut format_js = UndefinedValue());
        format.to_jsval(cx, format_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "format", format_js.handle()).unwrap();
        let stencilBack = &self.stencilBack;
        rooted!(in(cx) let mut stencilBack_js = UndefinedValue());
        stencilBack.to_jsval(cx, stencilBack_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencilBack", stencilBack_js.handle()).unwrap();
        let stencilFront = &self.stencilFront;
        rooted!(in(cx) let mut stencilFront_js = UndefinedValue());
        stencilFront.to_jsval(cx, stencilFront_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencilFront", stencilFront_js.handle()).unwrap();
        let stencilReadMask = &self.stencilReadMask;
        rooted!(in(cx) let mut stencilReadMask_js = UndefinedValue());
        stencilReadMask.to_jsval(cx, stencilReadMask_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencilReadMask", stencilReadMask_js.handle()).unwrap();
        let stencilWriteMask = &self.stencilWriteMask;
        rooted!(in(cx) let mut stencilWriteMask_js = UndefinedValue());
        stencilWriteMask.to_jsval(cx, stencilWriteMask_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencilWriteMask", stencilWriteMask_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUDepthStencilState {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUStencilFaceState {
    pub compare: GPUCompareFunction,
    pub depthFailOp: GPUStencilOperation,
    pub failOp: GPUStencilOperation,
    pub passOp: GPUStencilOperation,
}
impl Default for GPUStencilFaceState {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUStencilFaceState {
    pub fn empty() -> Self {
        Self {
                compare: GPUCompareFunction::Always,
                depthFailOp: GPUStencilOperation::Keep,
                failOp: GPUStencilOperation::Keep,
                passOp: GPUStencilOperation::Keep,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUStencilFaceState>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUStencilFaceState {
                compare: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "compare", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUCompareFunction::Always
                    }
                },
                depthFailOp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthFailOp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUStencilOperation::Keep
                    }
                },
                failOp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "failOp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUStencilOperation::Keep
                    }
                },
                passOp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "passOp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUStencilOperation::Keep
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUStencilFaceState {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUStencilFaceState>, ()> {
        GPUStencilFaceState::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUStencilFaceState {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let compare = &self.compare;
        rooted!(in(cx) let mut compare_js = UndefinedValue());
        compare.to_jsval(cx, compare_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "compare", compare_js.handle()).unwrap();
        let depthFailOp = &self.depthFailOp;
        rooted!(in(cx) let mut depthFailOp_js = UndefinedValue());
        depthFailOp.to_jsval(cx, depthFailOp_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthFailOp", depthFailOp_js.handle()).unwrap();
        let failOp = &self.failOp;
        rooted!(in(cx) let mut failOp_js = UndefinedValue());
        failOp.to_jsval(cx, failOp_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "failOp", failOp_js.handle()).unwrap();
        let passOp = &self.passOp;
        rooted!(in(cx) let mut passOp_js = UndefinedValue());
        passOp.to_jsval(cx, passOp_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "passOp", passOp_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUStencilFaceState {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUVertexState<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUProgrammableStage<D>,
    pub buffers: Vec<crate::codegen::GenericBindings::WebGPUBinding::GPUVertexBufferLayout>,
}

impl<D: DomTypes> GPUVertexState<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUVertexState<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUVertexState {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUProgrammableStage::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                buffers: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "buffers", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            Vec::new()
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUVertexState<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUVertexState<D>>, ()> {
        GPUVertexState::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUVertexState<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let buffers = &self.buffers;
        rooted!(in(cx) let mut buffers_js = UndefinedValue());
        buffers.to_jsval(cx, buffers_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "buffers", buffers_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUVertexState<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUVertexBufferLayout {
    pub arrayStride: u64,
    pub attributes: Vec<crate::codegen::GenericBindings::WebGPUBinding::GPUVertexAttribute>,
    pub stepMode: GPUVertexStepMode,
}

impl GPUVertexBufferLayout {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUVertexBufferLayout>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUVertexBufferLayout {
                arrayStride: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "arrayStride", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"arrayStride\".");
                            return Err(());
                    }
                },
                attributes: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "attributes", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"attributes\".");
                            return Err(());
                    }
                },
                stepMode: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stepMode", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUVertexStepMode::Vertex
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUVertexBufferLayout {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUVertexBufferLayout>, ()> {
        GPUVertexBufferLayout::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUVertexBufferLayout {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let arrayStride = &self.arrayStride;
        rooted!(in(cx) let mut arrayStride_js = UndefinedValue());
        arrayStride.to_jsval(cx, arrayStride_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "arrayStride", arrayStride_js.handle()).unwrap();
        let attributes = &self.attributes;
        rooted!(in(cx) let mut attributes_js = UndefinedValue());
        attributes.to_jsval(cx, attributes_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "attributes", attributes_js.handle()).unwrap();
        let stepMode = &self.stepMode;
        rooted!(in(cx) let mut stepMode_js = UndefinedValue());
        stepMode.to_jsval(cx, stepMode_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stepMode", stepMode_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUVertexBufferLayout {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUVertexAttribute {
    pub format: GPUVertexFormat,
    pub offset: u64,
    pub shaderLocation: u32,
}

impl GPUVertexAttribute {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUVertexAttribute>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUVertexAttribute {
                format: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "format", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"format\".");
                            return Err(());
                    }
                },
                offset: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "offset", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"offset\".");
                            return Err(());
                    }
                },
                shaderLocation: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "shaderLocation", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"shaderLocation\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUVertexAttribute {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUVertexAttribute>, ()> {
        GPUVertexAttribute::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUVertexAttribute {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let format = &self.format;
        rooted!(in(cx) let mut format_js = UndefinedValue());
        format.to_jsval(cx, format_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "format", format_js.handle()).unwrap();
        let offset = &self.offset;
        rooted!(in(cx) let mut offset_js = UndefinedValue());
        offset.to_jsval(cx, offset_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "offset", offset_js.handle()).unwrap();
        let shaderLocation = &self.shaderLocation;
        rooted!(in(cx) let mut shaderLocation_js = UndefinedValue());
        shaderLocation.to_jsval(cx, shaderLocation_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "shaderLocation", shaderLocation_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUVertexAttribute {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUImageDataLayout {
    pub bytesPerRow: Option<u32>,
    pub offset: u64,
    pub rowsPerImage: Option<u32>,
}
impl Default for GPUImageDataLayout {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUImageDataLayout {
    pub fn empty() -> Self {
        Self {
                bytesPerRow: None,
                offset: 0,
                rowsPerImage: None,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUImageDataLayout>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUImageDataLayout {
                bytesPerRow: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "bytesPerRow", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                offset: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "offset", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                rowsPerImage: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "rowsPerImage", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUImageDataLayout {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUImageDataLayout>, ()> {
        GPUImageDataLayout::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUImageDataLayout {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        if let Some(ref bytesPerRow) = self.bytesPerRow {
            rooted!(in(cx) let mut bytesPerRow_js = UndefinedValue());
            bytesPerRow.to_jsval(cx, bytesPerRow_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "bytesPerRow", bytesPerRow_js.handle()).unwrap();
        }
        let offset = &self.offset;
        rooted!(in(cx) let mut offset_js = UndefinedValue());
        offset.to_jsval(cx, offset_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "offset", offset_js.handle()).unwrap();
        if let Some(ref rowsPerImage) = self.rowsPerImage {
            rooted!(in(cx) let mut rowsPerImage_js = UndefinedValue());
            rowsPerImage.to_jsval(cx, rowsPerImage_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "rowsPerImage", rowsPerImage_js.handle()).unwrap();
        }
    }
}

impl ToJSValConvertible for GPUImageDataLayout {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUImageCopyBuffer<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUImageDataLayout,
    pub buffer: DomRoot<D::GPUBuffer>,
}

impl<D: DomTypes> GPUImageCopyBuffer<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUImageCopyBuffer<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUImageCopyBuffer {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUImageDataLayout::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                buffer: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "buffer", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            }
                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"buffer\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUImageCopyBuffer<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUImageCopyBuffer<D>>, ()> {
        GPUImageCopyBuffer::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUImageCopyBuffer<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let buffer = &self.buffer;
        rooted!(in(cx) let mut buffer_js = UndefinedValue());
        buffer.to_jsval(cx, buffer_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "buffer", buffer_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUImageCopyBuffer<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUImageCopyTexture<D: DomTypes> {
    pub aspect: GPUTextureAspect,
    pub mipLevel: u32,
    pub origin: Option<GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUOrigin3DDict>,
    pub texture: DomRoot<D::GPUTexture>,
}

impl<D: DomTypes> GPUImageCopyTexture<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUImageCopyTexture<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUImageCopyTexture {
                aspect: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "aspect", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUTextureAspect::All
                    }
                },
                mipLevel: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "mipLevel", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                origin: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "origin", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                texture: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "texture", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUTexture.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            }
                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"texture\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUImageCopyTexture<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUImageCopyTexture<D>>, ()> {
        GPUImageCopyTexture::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUImageCopyTexture<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let aspect = &self.aspect;
        rooted!(in(cx) let mut aspect_js = UndefinedValue());
        aspect.to_jsval(cx, aspect_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "aspect", aspect_js.handle()).unwrap();
        let mipLevel = &self.mipLevel;
        rooted!(in(cx) let mut mipLevel_js = UndefinedValue());
        mipLevel.to_jsval(cx, mipLevel_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "mipLevel", mipLevel_js.handle()).unwrap();
        if let Some(ref origin) = self.origin {
            rooted!(in(cx) let mut origin_js = UndefinedValue());
            origin.to_jsval(cx, origin_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "origin", origin_js.handle()).unwrap();
        }
        let texture = &self.texture;
        rooted!(in(cx) let mut texture_js = UndefinedValue());
        texture.to_jsval(cx, texture_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "texture", texture_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUImageCopyTexture<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUImageCopyTextureTagged<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D>,
    pub premultipliedAlpha: bool,
}

impl<D: DomTypes> GPUImageCopyTextureTagged<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUImageCopyTextureTagged<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUImageCopyTextureTagged {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                premultipliedAlpha: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "premultipliedAlpha", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUImageCopyTextureTagged<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUImageCopyTextureTagged<D>>, ()> {
        GPUImageCopyTextureTagged::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUImageCopyTextureTagged<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let premultipliedAlpha = &self.premultipliedAlpha;
        rooted!(in(cx) let mut premultipliedAlpha_js = UndefinedValue());
        premultipliedAlpha.to_jsval(cx, premultipliedAlpha_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "premultipliedAlpha", premultipliedAlpha_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUImageCopyTextureTagged<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUImageCopyExternalImage<D: DomTypes> {
    pub flipY: bool,
    pub origin: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict,
    pub source: GenericUnionTypes::ImageBitmapOrHTMLCanvasElementOrOffscreenCanvas::<D>,
}

impl<D: DomTypes> GPUImageCopyExternalImage<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUImageCopyExternalImage<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUImageCopyExternalImage {
                flipY: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "flipY", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                origin: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "origin", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict::GPUOrigin2DDict(crate::codegen::GenericBindings::WebGPUBinding::GPUOrigin2DDict::empty())
                    }
                },
                source: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "source", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"source\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUImageCopyExternalImage<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUImageCopyExternalImage<D>>, ()> {
        GPUImageCopyExternalImage::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUImageCopyExternalImage<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let flipY = &self.flipY;
        rooted!(in(cx) let mut flipY_js = UndefinedValue());
        flipY.to_jsval(cx, flipY_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "flipY", flipY_js.handle()).unwrap();
        let origin = &self.origin;
        rooted!(in(cx) let mut origin_js = UndefinedValue());
        origin.to_jsval(cx, origin_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "origin", origin_js.handle()).unwrap();
        let source = &self.source;
        rooted!(in(cx) let mut source_js = UndefinedValue());
        source.to_jsval(cx, source_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "source", source_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUImageCopyExternalImage<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUCommandBufferDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,

}
impl Default for GPUCommandBufferDescriptor {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUCommandBufferDescriptor {
    pub fn empty() -> Self {
        Self {
                parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::empty(),
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUCommandBufferDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUCommandBufferDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUCommandBufferDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUCommandBufferDescriptor>, ()> {
        GPUCommandBufferDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUCommandBufferDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
    }
}

impl ToJSValConvertible for GPUCommandBufferDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUImageBitmapCopyView {
    pub origin: Option<GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUOrigin2DDict>,
}
impl Default for GPUImageBitmapCopyView {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUImageBitmapCopyView {
    pub fn empty() -> Self {
        Self {
                origin: None,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUImageBitmapCopyView>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUImageBitmapCopyView {
                origin: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "origin", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUImageBitmapCopyView {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUImageBitmapCopyView>, ()> {
        GPUImageBitmapCopyView::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUImageBitmapCopyView {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        if let Some(ref origin) = self.origin {
            rooted!(in(cx) let mut origin_js = UndefinedValue());
            origin.to_jsval(cx, origin_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "origin", origin_js.handle()).unwrap();
        }
    }
}

impl ToJSValConvertible for GPUImageBitmapCopyView {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUCommandEncoderDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub measureExecutionTime: bool,
}
impl Default for GPUCommandEncoderDescriptor {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUCommandEncoderDescriptor {
    pub fn empty() -> Self {
        Self {
                parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::empty(),
                measureExecutionTime: false,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUCommandEncoderDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUCommandEncoderDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                measureExecutionTime: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "measureExecutionTime", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUCommandEncoderDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUCommandEncoderDescriptor>, ()> {
        GPUCommandEncoderDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUCommandEncoderDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let measureExecutionTime = &self.measureExecutionTime;
        rooted!(in(cx) let mut measureExecutionTime_js = UndefinedValue());
        measureExecutionTime.to_jsval(cx, measureExecutionTime_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "measureExecutionTime", measureExecutionTime_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUCommandEncoderDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUComputePassDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,

}
impl Default for GPUComputePassDescriptor {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUComputePassDescriptor {
    pub fn empty() -> Self {
        Self {
                parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::empty(),
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUComputePassDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUComputePassDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUComputePassDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUComputePassDescriptor>, ()> {
        GPUComputePassDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUComputePassDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
    }
}

impl ToJSValConvertible for GPUComputePassDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPURenderPassDescriptor<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub colorAttachments: Vec<crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassColorAttachment<D>>,
    pub depthStencilAttachment: Option<crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassDepthStencilAttachment<D>>,
    pub occlusionQuerySet: Option<DomRoot<D::GPUQuerySet>>,
}

impl<D: DomTypes> GPURenderPassDescriptor<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPURenderPassDescriptor<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPURenderPassDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                colorAttachments: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "colorAttachments", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"colorAttachments\".");
                            return Err(());
                    }
                },
                depthStencilAttachment: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthStencilAttachment", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                occlusionQuerySet: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "occlusionQuerySet", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUQuerySet.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            })
                    } else {
                            None
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPURenderPassDescriptor<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPURenderPassDescriptor<D>>, ()> {
        GPURenderPassDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPURenderPassDescriptor<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let colorAttachments = &self.colorAttachments;
        rooted!(in(cx) let mut colorAttachments_js = UndefinedValue());
        colorAttachments.to_jsval(cx, colorAttachments_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "colorAttachments", colorAttachments_js.handle()).unwrap();
        if let Some(ref depthStencilAttachment) = self.depthStencilAttachment {
            rooted!(in(cx) let mut depthStencilAttachment_js = UndefinedValue());
            depthStencilAttachment.to_jsval(cx, depthStencilAttachment_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthStencilAttachment", depthStencilAttachment_js.handle()).unwrap();
        }
        if let Some(ref occlusionQuerySet) = self.occlusionQuerySet {
            rooted!(in(cx) let mut occlusionQuerySet_js = UndefinedValue());
            occlusionQuerySet.to_jsval(cx, occlusionQuerySet_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "occlusionQuerySet", occlusionQuerySet_js.handle()).unwrap();
        }
    }
}

impl<D: DomTypes> ToJSValConvertible for GPURenderPassDescriptor<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPURenderPassColorAttachment<D: DomTypes> {
    pub clearValue: Option<GenericUnionTypes::DoubleSequenceOrGPUColorDict>,
    pub loadOp: GPULoadOp,
    pub resolveTarget: Option<DomRoot<D::GPUTextureView>>,
    pub storeOp: GPUStoreOp,
    pub view: DomRoot<D::GPUTextureView>,
}

impl<D: DomTypes> GPURenderPassColorAttachment<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPURenderPassColorAttachment<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPURenderPassColorAttachment {
                clearValue: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "clearValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                loadOp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "loadOp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"loadOp\".");
                            return Err(());
                    }
                },
                resolveTarget: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "resolveTarget", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUTextureView.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            })
                    } else {
                            None
                    }
                },
                storeOp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "storeOp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"storeOp\".");
                            return Err(());
                    }
                },
                view: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "view", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUTextureView.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            }
                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"view\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPURenderPassColorAttachment<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPURenderPassColorAttachment<D>>, ()> {
        GPURenderPassColorAttachment::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPURenderPassColorAttachment<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        if let Some(ref clearValue) = self.clearValue {
            rooted!(in(cx) let mut clearValue_js = UndefinedValue());
            clearValue.to_jsval(cx, clearValue_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "clearValue", clearValue_js.handle()).unwrap();
        }
        let loadOp = &self.loadOp;
        rooted!(in(cx) let mut loadOp_js = UndefinedValue());
        loadOp.to_jsval(cx, loadOp_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "loadOp", loadOp_js.handle()).unwrap();
        if let Some(ref resolveTarget) = self.resolveTarget {
            rooted!(in(cx) let mut resolveTarget_js = UndefinedValue());
            resolveTarget.to_jsval(cx, resolveTarget_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "resolveTarget", resolveTarget_js.handle()).unwrap();
        }
        let storeOp = &self.storeOp;
        rooted!(in(cx) let mut storeOp_js = UndefinedValue());
        storeOp.to_jsval(cx, storeOp_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "storeOp", storeOp_js.handle()).unwrap();
        let view = &self.view;
        rooted!(in(cx) let mut view_js = UndefinedValue());
        view.to_jsval(cx, view_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "view", view_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPURenderPassColorAttachment<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPURenderPassDepthStencilAttachment<D: DomTypes> {
    pub depthClearValue: Option<Finite<f32>>,
    pub depthLoadOp: Option<GPULoadOp>,
    pub depthReadOnly: bool,
    pub depthStoreOp: Option<GPUStoreOp>,
    pub stencilClearValue: u32,
    pub stencilLoadOp: Option<GPULoadOp>,
    pub stencilReadOnly: bool,
    pub stencilStoreOp: Option<GPUStoreOp>,
    pub view: DomRoot<D::GPUTextureView>,
}

impl<D: DomTypes> GPURenderPassDepthStencilAttachment<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPURenderPassDepthStencilAttachment<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPURenderPassDepthStencilAttachment {
                depthClearValue: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthClearValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                depthLoadOp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthLoadOp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                depthReadOnly: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthReadOnly", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                depthStoreOp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthStoreOp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                stencilClearValue: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stencilClearValue", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                stencilLoadOp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stencilLoadOp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                stencilReadOnly: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stencilReadOnly", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                stencilStoreOp: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stencilStoreOp", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                view: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "view", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUTextureView.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            }
                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"view\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPURenderPassDepthStencilAttachment<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPURenderPassDepthStencilAttachment<D>>, ()> {
        GPURenderPassDepthStencilAttachment::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPURenderPassDepthStencilAttachment<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        if let Some(ref depthClearValue) = self.depthClearValue {
            rooted!(in(cx) let mut depthClearValue_js = UndefinedValue());
            depthClearValue.to_jsval(cx, depthClearValue_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthClearValue", depthClearValue_js.handle()).unwrap();
        }
        if let Some(ref depthLoadOp) = self.depthLoadOp {
            rooted!(in(cx) let mut depthLoadOp_js = UndefinedValue());
            depthLoadOp.to_jsval(cx, depthLoadOp_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthLoadOp", depthLoadOp_js.handle()).unwrap();
        }
        let depthReadOnly = &self.depthReadOnly;
        rooted!(in(cx) let mut depthReadOnly_js = UndefinedValue());
        depthReadOnly.to_jsval(cx, depthReadOnly_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthReadOnly", depthReadOnly_js.handle()).unwrap();
        if let Some(ref depthStoreOp) = self.depthStoreOp {
            rooted!(in(cx) let mut depthStoreOp_js = UndefinedValue());
            depthStoreOp.to_jsval(cx, depthStoreOp_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthStoreOp", depthStoreOp_js.handle()).unwrap();
        }
        let stencilClearValue = &self.stencilClearValue;
        rooted!(in(cx) let mut stencilClearValue_js = UndefinedValue());
        stencilClearValue.to_jsval(cx, stencilClearValue_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencilClearValue", stencilClearValue_js.handle()).unwrap();
        if let Some(ref stencilLoadOp) = self.stencilLoadOp {
            rooted!(in(cx) let mut stencilLoadOp_js = UndefinedValue());
            stencilLoadOp.to_jsval(cx, stencilLoadOp_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencilLoadOp", stencilLoadOp_js.handle()).unwrap();
        }
        let stencilReadOnly = &self.stencilReadOnly;
        rooted!(in(cx) let mut stencilReadOnly_js = UndefinedValue());
        stencilReadOnly.to_jsval(cx, stencilReadOnly_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencilReadOnly", stencilReadOnly_js.handle()).unwrap();
        if let Some(ref stencilStoreOp) = self.stencilStoreOp {
            rooted!(in(cx) let mut stencilStoreOp_js = UndefinedValue());
            stencilStoreOp.to_jsval(cx, stencilStoreOp_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencilStoreOp", stencilStoreOp_js.handle()).unwrap();
        }
        let view = &self.view;
        rooted!(in(cx) let mut view_js = UndefinedValue());
        view.to_jsval(cx, view_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "view", view_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPURenderPassDepthStencilAttachment<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPURenderPassLayout {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub colorFormats: Vec<GPUTextureFormat>,
    pub depthStencilFormat: Option<GPUTextureFormat>,
    pub sampleCount: u32,
}

impl GPURenderPassLayout {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPURenderPassLayout>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPURenderPassLayout {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                colorFormats: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "colorFormats", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"colorFormats\".");
                            return Err(());
                    }
                },
                depthStencilFormat: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthStencilFormat", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }
                            )
                    } else {
                            None
                    }
                },
                sampleCount: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "sampleCount", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            1
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPURenderPassLayout {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPURenderPassLayout>, ()> {
        GPURenderPassLayout::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPURenderPassLayout {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let colorFormats = &self.colorFormats;
        rooted!(in(cx) let mut colorFormats_js = UndefinedValue());
        colorFormats.to_jsval(cx, colorFormats_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "colorFormats", colorFormats_js.handle()).unwrap();
        if let Some(ref depthStencilFormat) = self.depthStencilFormat {
            rooted!(in(cx) let mut depthStencilFormat_js = UndefinedValue());
            depthStencilFormat.to_jsval(cx, depthStencilFormat_js.handle_mut());
            set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthStencilFormat", depthStencilFormat_js.handle()).unwrap();
        }
        let sampleCount = &self.sampleCount;
        rooted!(in(cx) let mut sampleCount_js = UndefinedValue());
        sampleCount.to_jsval(cx, sampleCount_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "sampleCount", sampleCount_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPURenderPassLayout {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPURenderBundleDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,

}
impl Default for GPURenderBundleDescriptor {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPURenderBundleDescriptor {
    pub fn empty() -> Self {
        Self {
                parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::empty(),
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPURenderBundleDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPURenderBundleDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPURenderBundleDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPURenderBundleDescriptor>, ()> {
        GPURenderBundleDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPURenderBundleDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
    }
}

impl ToJSValConvertible for GPURenderBundleDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPURenderBundleEncoderDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassLayout,
    pub depthReadOnly: bool,
    pub stencilReadOnly: bool,
}

impl GPURenderBundleEncoderDescriptor {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPURenderBundleEncoderDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPURenderBundleEncoderDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassLayout::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                depthReadOnly: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthReadOnly", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
                stencilReadOnly: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "stencilReadOnly", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            false
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPURenderBundleEncoderDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPURenderBundleEncoderDescriptor>, ()> {
        GPURenderBundleEncoderDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPURenderBundleEncoderDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let depthReadOnly = &self.depthReadOnly;
        rooted!(in(cx) let mut depthReadOnly_js = UndefinedValue());
        depthReadOnly.to_jsval(cx, depthReadOnly_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthReadOnly", depthReadOnly_js.handle()).unwrap();
        let stencilReadOnly = &self.stencilReadOnly;
        rooted!(in(cx) let mut stencilReadOnly_js = UndefinedValue());
        stencilReadOnly.to_jsval(cx, stencilReadOnly_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "stencilReadOnly", stencilReadOnly_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPURenderBundleEncoderDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUQuerySetDescriptor {
    pub parent: crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase,
    pub count: u32,
    pub pipelineStatistics: Vec<GPUPipelineStatisticName>,
    pub type_: GPUQueryType,
}

impl GPUQuerySetDescriptor {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUQuerySetDescriptor>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUQuerySetDescriptor {
                parent: {
                    match crate::codegen::GenericBindings::WebGPUBinding::GPUObjectDescriptorBase::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                count: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "count", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"count\".");
                            return Err(());
                    }
                },
                pipelineStatistics: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "pipelineStatistics", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            Vec::new()
                    }
                },
                type_: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "type", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"type\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUQuerySetDescriptor {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUQuerySetDescriptor>, ()> {
        GPUQuerySetDescriptor::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUQuerySetDescriptor {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let count = &self.count;
        rooted!(in(cx) let mut count_js = UndefinedValue());
        count.to_jsval(cx, count_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "count", count_js.handle()).unwrap();
        let pipelineStatistics = &self.pipelineStatistics;
        rooted!(in(cx) let mut pipelineStatistics_js = UndefinedValue());
        pipelineStatistics.to_jsval(cx, pipelineStatistics_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "pipelineStatistics", pipelineStatistics_js.handle()).unwrap();
        let type_ = &self.type_;
        rooted!(in(cx) let mut type__js = UndefinedValue());
        type_.to_jsval(cx, type__js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "type", type__js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUQuerySetDescriptor {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUCanvasConfiguration<D: DomTypes> {
    pub alphaMode: GPUCanvasAlphaMode,
    pub device: DomRoot<D::GPUDevice>,
    pub format: GPUTextureFormat,
    pub usage: u32,
    pub viewFormats: Vec<GPUTextureFormat>,
}

#[allow(clippy::clone_on_copy)]
impl<D: DomTypes> Clone for GPUCanvasConfiguration<D> {
    fn clone(&self) -> Self {
        Self {
            alphaMode: self.alphaMode.clone(),
            device: self.device.clone(),
            format: self.format.clone(),
            usage: self.usage.clone(),
            viewFormats: self.viewFormats.clone(),
        }
    }
}

impl<D: DomTypes> GPUCanvasConfiguration<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUCanvasConfiguration<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUCanvasConfiguration {
                alphaMode: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "alphaMode", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            GPUCanvasAlphaMode::Opaque
                    }
                },
                device: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "device", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUDevice.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            }
                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"device\".");
                            return Err(());
                    }
                },
                format: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "format", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error); return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"format\".");
                            return Err(());
                    }
                },
                usage: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "usage", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            16
                    }
                },
                viewFormats: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "viewFormats", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            Vec::new()
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUCanvasConfiguration<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUCanvasConfiguration<D>>, ()> {
        GPUCanvasConfiguration::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUCanvasConfiguration<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let alphaMode = &self.alphaMode;
        rooted!(in(cx) let mut alphaMode_js = UndefinedValue());
        alphaMode.to_jsval(cx, alphaMode_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "alphaMode", alphaMode_js.handle()).unwrap();
        let device = &self.device;
        rooted!(in(cx) let mut device_js = UndefinedValue());
        device.to_jsval(cx, device_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "device", device_js.handle()).unwrap();
        let format = &self.format;
        rooted!(in(cx) let mut format_js = UndefinedValue());
        format.to_jsval(cx, format_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "format", format_js.handle()).unwrap();
        let usage = &self.usage;
        rooted!(in(cx) let mut usage_js = UndefinedValue());
        usage.to_jsval(cx, usage_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "usage", usage_js.handle()).unwrap();
        let viewFormats = &self.viewFormats;
        rooted!(in(cx) let mut viewFormats_js = UndefinedValue());
        viewFormats.to_jsval(cx, viewFormats_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "viewFormats", viewFormats_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUCanvasConfiguration<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUUncapturedErrorEventInit<D: DomTypes> {
    pub parent: crate::codegen::GenericBindings::EventBinding::EventInit,
    pub error: DomRoot<D::GPUError>,
}

impl<D: DomTypes> GPUUncapturedErrorEventInit<D> {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUUncapturedErrorEventInit<D>>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUUncapturedErrorEventInit {
                parent: {
                    match crate::codegen::GenericBindings::EventBinding::EventInit::new(cx, val, can_gc)? {
                        ConversionResult::Success(v) => v,
                        ConversionResult::Failure(error) => {
                            throw_type_error(cx.raw_cx(), &error);
                            return Err(());
                        }
                    }
                },
                error: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "error", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            if rval.handle().get().is_object() {
                                match root_from_handlevalue(rval.handle(), SafeJSContext::from_ptr(cx.raw_cx())) {
                                    Ok(val) => val,
                                    Err(()) => {
                                        throw_type_error(cx.raw_cx(), "value does not implement interface GPUError.");
                                        return Err(());

                                    }
                                }

                            } else {
                                throw_type_error(cx.raw_cx(), "Value is not an object.");
                                return Err(());

                            }
                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"error\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl<D: DomTypes> FromJSValConvertible for GPUUncapturedErrorEventInit<D> {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUUncapturedErrorEventInit<D>>, ()> {
        GPUUncapturedErrorEventInit::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl<D: DomTypes> GPUUncapturedErrorEventInit<D> {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        self.parent.to_jsobject(cx, obj.reborrow());
        let error = &self.error;
        rooted!(in(cx) let mut error_js = UndefinedValue());
        error.to_jsval(cx, error_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "error", error_js.handle()).unwrap();
    }
}

impl<D: DomTypes> ToJSValConvertible for GPUUncapturedErrorEventInit<D> {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUColorDict {
    pub a: Finite<f64>,
    pub b: Finite<f64>,
    pub g: Finite<f64>,
    pub r: Finite<f64>,
}

impl GPUColorDict {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUColorDict>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUColorDict {
                a: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "a", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"a\".");
                            return Err(());
                    }
                },
                b: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "b", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"b\".");
                            return Err(());
                    }
                },
                g: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "g", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"g\".");
                            return Err(());
                    }
                },
                r: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "r", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ()) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"r\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUColorDict {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUColorDict>, ()> {
        GPUColorDict::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUColorDict {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let a = &self.a;
        rooted!(in(cx) let mut a_js = UndefinedValue());
        a.to_jsval(cx, a_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "a", a_js.handle()).unwrap();
        let b = &self.b;
        rooted!(in(cx) let mut b_js = UndefinedValue());
        b.to_jsval(cx, b_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "b", b_js.handle()).unwrap();
        let g = &self.g;
        rooted!(in(cx) let mut g_js = UndefinedValue());
        g.to_jsval(cx, g_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "g", g_js.handle()).unwrap();
        let r = &self.r;
        rooted!(in(cx) let mut r_js = UndefinedValue());
        r.to_jsval(cx, r_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "r", r_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUColorDict {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUOrigin2DDict {
    pub x: u32,
    pub y: u32,
}
impl Default for GPUOrigin2DDict {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUOrigin2DDict {
    pub fn empty() -> Self {
        Self {
                x: 0,
                y: 0,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUOrigin2DDict>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUOrigin2DDict {
                x: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "x", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                y: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "y", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUOrigin2DDict {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUOrigin2DDict>, ()> {
        GPUOrigin2DDict::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUOrigin2DDict {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let x = &self.x;
        rooted!(in(cx) let mut x_js = UndefinedValue());
        x.to_jsval(cx, x_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "x", x_js.handle()).unwrap();
        let y = &self.y;
        rooted!(in(cx) let mut y_js = UndefinedValue());
        y.to_jsval(cx, y_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "y", y_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUOrigin2DDict {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable)]
pub struct GPUOrigin3DDict {
    pub x: u32,
    pub y: u32,
    pub z: u32,
}
impl Default for GPUOrigin3DDict {
    fn default() -> Self {
        Self::empty()
    }
}

impl GPUOrigin3DDict {
    pub fn empty() -> Self {
        Self {
                x: 0,
                y: 0,
                z: 0,
        }
    }
    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUOrigin3DDict>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUOrigin3DDict {
                x: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "x", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                y: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "y", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
                z: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "z", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            0
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUOrigin3DDict {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUOrigin3DDict>, ()> {
        GPUOrigin3DDict::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUOrigin3DDict {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let x = &self.x;
        rooted!(in(cx) let mut x_js = UndefinedValue());
        x.to_jsval(cx, x_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "x", x_js.handle()).unwrap();
        let y = &self.y;
        rooted!(in(cx) let mut y_js = UndefinedValue());
        y.to_jsval(cx, y_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "y", y_js.handle()).unwrap();
        let z = &self.z;
        rooted!(in(cx) let mut z_js = UndefinedValue());
        z.to_jsval(cx, z_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "z", z_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUOrigin3DDict {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


#[derive(JSTraceable, MallocSizeOf)]
pub struct GPUExtent3DDict {
    pub depthOrArrayLayers: u32,
    pub height: u32,
    pub width: u32,
}

impl GPUExtent3DDict {

    pub fn new(cx: SafeJSContext, val: HandleValue, can_gc: CanGc)
                      -> Result<ConversionResult<GPUExtent3DDict>, ()> {
        unsafe {
            let object = if val.get().is_null_or_undefined() {
                ptr::null_mut()
            } else if val.get().is_object() {
                val.get().to_object()
            } else {
                return Ok(ConversionResult::Failure("Value is not an object.".into()));
            };
            rooted!(&in(cx) let object = object);
        let dictionary = GPUExtent3DDict {
                depthOrArrayLayers: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "depthOrArrayLayers", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            1
                    }
                },
                height: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "height", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            1
                    }
                },
                width: {
                    rooted!(&in(cx) let mut rval = UndefinedValue());
                    if get_dictionary_property(cx.raw_cx(), object.handle(), "width", rval.handle_mut(), can_gc)? && !rval.is_undefined() {
                            match FromJSValConvertible::from_jsval(cx.raw_cx(), rval.handle(), ConversionBehavior::EnforceRange) {
                                Ok(ConversionResult::Success(value)) => value,
                                Ok(ConversionResult::Failure(error)) => {
                                    throw_type_error(cx.raw_cx(), &error);
                            return Err(());

                                }
                                _ => {
                                    return Err(());

                                },
                            }

                    } else {
                            throw_type_error(cx.raw_cx(), "Missing required member \"width\".");
                            return Err(());
                    }
                },
        };
            Ok(ConversionResult::Success(dictionary))
        }
    }
}

impl FromJSValConvertible for GPUExtent3DDict {
    type Config = ();
    unsafe fn from_jsval(cx: *mut RawJSContext, value: HandleValue, _option: ())
                         -> Result<ConversionResult<GPUExtent3DDict>, ()> {
        GPUExtent3DDict::new(SafeJSContext::from_ptr(cx), value, CanGc::note())
    }
}

impl GPUExtent3DDict {
    #[allow(clippy::wrong_self_convention)]
    pub unsafe fn to_jsobject(&self, cx: *mut RawJSContext, mut obj: MutableHandleObject) {
        let depthOrArrayLayers = &self.depthOrArrayLayers;
        rooted!(in(cx) let mut depthOrArrayLayers_js = UndefinedValue());
        depthOrArrayLayers.to_jsval(cx, depthOrArrayLayers_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "depthOrArrayLayers", depthOrArrayLayers_js.handle()).unwrap();
        let height = &self.height;
        rooted!(in(cx) let mut height_js = UndefinedValue());
        height.to_jsval(cx, height_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "height", height_js.handle()).unwrap();
        let width = &self.width;
        rooted!(in(cx) let mut width_js = UndefinedValue());
        width.to_jsval(cx, width_js.handle_mut());
        set_dictionary_property(SafeJSContext::from_ptr(cx), obj.handle(), "width", width_js.handle()).unwrap();
    }
}

impl ToJSValConvertible for GPUExtent3DDict {
    unsafe fn to_jsval(&self, cx: *mut RawJSContext, mut rval: MutableHandleValue) {
        rooted!(in(cx) let mut obj = JS_NewObject(cx, ptr::null()));
        self.to_jsobject(cx, obj.handle_mut());
        rval.set(ObjectOrNullValue(obj.get()))
    }
}


pub use self::GPU_Binding::{Wrap as GPUWrap, GPUMethods, GetProtoObject as GPUGetProtoObject, DefineDOMInterface as GPUDefineDOMInterface};
pub mod GPU_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUPowerPreference;
use crate::codegen::GenericBindings::WebGPUBinding::GPUPowerPreferenceValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPURequestAdapterOptions;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureFormat;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureFormatValues;
use crate::import::module::*;

unsafe extern "C" fn requestAdapter<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPU);
        let args = &*args;
        let argc = args.argc_;
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPURequestAdapterOptions = if args.get(0).is_undefined() {
            crate::codegen::GenericBindings::WebGPUBinding::GPURequestAdapterOptions::empty()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: Rc<D::Promise> = this.RequestAdapter(&arg0, InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn requestAdapter_promise_wrapper<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let ok = requestAdapter::<D>(cx, _obj, this, args);
        if ok {
          return true;
        }
        return exception_to_promise(cx, (*args).rval(), CanGc::note());

    })());
    result
}


static requestAdapter_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_requestAdapter_methodinfo<D: DomTypes>() {
    requestAdapter_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(requestAdapter_promise_wrapper::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPU as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn getPreferredCanvasFormat<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPU);
        let args = &*args;
        let argc = args.argc_;
        let result: GPUTextureFormat = this.GetPreferredCanvasFormat();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static getPreferredCanvasFormat_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_getPreferredCanvasFormat_methodinfo<D: DomTypes>() {
    getPreferredCanvasFormat_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(getPreferredCanvasFormat::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPU as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_wgslLanguageFeatures<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPU);
        let result: DomRoot<D::WGSLLanguageFeatures> = this.WgslLanguageFeatures(CanGc::note());

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static wgslLanguageFeatures_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_wgslLanguageFeatures_getterinfo<D: DomTypes>() {
    wgslLanguageFeatures_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_wgslLanguageFeatures::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPU as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasNone as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            true,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPU>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPU>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPU".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPU, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPU> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPU>, _can_gc: CanGc) -> DomRoot<D::GPU>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUMethods<D: DomTypes> {
    fn RequestAdapter(&self, r#options: &crate::codegen::GenericBindings::WebGPUBinding::GPURequestAdapterOptions, r#_comp: InRealm, r#_can_gc: CanGc) -> Rc<D::Promise>;
    fn GetPreferredCanvasFormat(&self, ) -> GPUTextureFormat;
    fn WgslLanguageFeatures(&self, r#_can_gc: CanGc) -> DomRoot<D::WGSLLanguageFeatures>;
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"requestAdapter".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { requestAdapter_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"getPreferredCanvasFormat".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getPreferredCanvasFormat_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"wgslLanguageFeatures".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { wgslLanguageFeatures_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPU".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPU), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPU() {\n    [native code]\n}",
        PrototypeList::ID::GPU,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPU),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPU as usize].is_null());
    (*cache)[PrototypeList::ID::GPU as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPU as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPU",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPU_Binding::init_requestAdapter_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPU_Binding::init_getPreferredCanvasFormat_methodinfo::<D>();
            init_wgslLanguageFeatures_getterinfo::<D>();


            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPU_Binding


pub use self::GPUAdapter_Binding::{Wrap as GPUAdapterWrap, GPUAdapterMethods, GetProtoObject as GPUAdapterGetProtoObject, DefineDOMInterface as GPUAdapterDefineDOMInterface};
pub mod GPUAdapter_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUDeviceDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUFeatureName;
use crate::codegen::GenericBindings::WebGPUBinding::GPUFeatureNameValues;
use crate::import::module::*;
use crate::record::Record;

unsafe extern "C" fn get_features<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapter);
        let result: DomRoot<D::GPUSupportedFeatures> = this.Features();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static features_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_features_getterinfo<D: DomTypes>() {
    features_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_features::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapter as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasNone as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            true,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_limits<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapter);
        let result: DomRoot<D::GPUSupportedLimits> = this.Limits();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static limits_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_limits_getterinfo<D: DomTypes>() {
    limits_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_limits::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapter as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasNone as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            true,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_info<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapter);
        let result: DomRoot<D::GPUAdapterInfo> = this.Info();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static info_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_info_getterinfo<D: DomTypes>() {
    info_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_info::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapter as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasNone as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            true,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn requestDevice<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapter);
        let args = &*args;
        let argc = args.argc_;
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUDeviceDescriptor = if args.get(0).is_undefined() {
            crate::codegen::GenericBindings::WebGPUBinding::GPUDeviceDescriptor::empty()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: Rc<D::Promise> = this.RequestDevice(&arg0, InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn requestDevice_promise_wrapper<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let ok = requestDevice::<D>(cx, _obj, this, args);
        if ok {
          return true;
        }
        return exception_to_promise(cx, (*args).rval(), CanGc::note());

    })());
    result
}


static requestDevice_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_requestDevice_methodinfo<D: DomTypes>() {
    requestDevice_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(requestDevice_promise_wrapper::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapter as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUAdapter>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUAdapter>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUAdapter".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUAdapter, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUAdapter> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUAdapter>, _can_gc: CanGc) -> DomRoot<D::GPUAdapter>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUAdapterMethods<D: DomTypes> {
    fn Features(&self, ) -> DomRoot<D::GPUSupportedFeatures>;
    fn Limits(&self, ) -> DomRoot<D::GPUSupportedLimits>;
    fn Info(&self, ) -> DomRoot<D::GPUAdapterInfo>;
    fn RequestDevice(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUDeviceDescriptor, r#_comp: InRealm, r#_can_gc: CanGc) -> Rc<D::Promise>;
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"requestDevice".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { requestDevice_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"features".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { features_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"limits".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { limits_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"info".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { info_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUAdapter".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUAdapter), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUAdapterPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUAdapter() {\n    [native code]\n}",
        PrototypeList::ID::GPUAdapter,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUAdapter),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUAdapter as usize].is_null());
    (*cache)[PrototypeList::ID::GPUAdapter as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUAdapter as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUAdapter",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUAdapter_Binding::init_requestDevice_methodinfo::<D>();
            init_features_getterinfo::<D>();
init_limits_getterinfo::<D>();
init_info_getterinfo::<D>();


            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUAdapter_Binding


pub use self::GPUAdapterInfo_Binding::{Wrap as GPUAdapterInfoWrap, GPUAdapterInfoMethods, GetProtoObject as GPUAdapterInfoGetProtoObject, DefineDOMInterface as GPUAdapterInfoDefineDOMInterface};
pub mod GPUAdapterInfo_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_vendor<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapterInfo);
        let result: DOMString = this.Vendor();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static vendor_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_vendor_getterinfo<D: DomTypes>() {
    vendor_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_vendor::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapterInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_architecture<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapterInfo);
        let result: DOMString = this.Architecture();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static architecture_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_architecture_getterinfo<D: DomTypes>() {
    architecture_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_architecture::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapterInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_device<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapterInfo);
        let result: DOMString = this.Device();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static device_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_device_getterinfo<D: DomTypes>() {
    device_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_device::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapterInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_description<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapterInfo);
        let result: DOMString = this.Description();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static description_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_description_getterinfo<D: DomTypes>() {
    description_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_description::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapterInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_subgroupMinSize<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapterInfo);
        let result: u32 = this.SubgroupMinSize();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static subgroupMinSize_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_subgroupMinSize_getterinfo<D: DomTypes>() {
    subgroupMinSize_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_subgroupMinSize::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapterInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_subgroupMaxSize<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapterInfo);
        let result: u32 = this.SubgroupMaxSize();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static subgroupMaxSize_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_subgroupMaxSize_getterinfo<D: DomTypes>() {
    subgroupMaxSize_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_subgroupMaxSize::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapterInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_isFallbackAdapter<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUAdapterInfo);
        let result: bool = this.IsFallbackAdapter();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static isFallbackAdapter_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_isFallbackAdapter_getterinfo<D: DomTypes>() {
    isFallbackAdapter_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_isFallbackAdapter::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUAdapterInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_BOOLEAN as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUAdapterInfo>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUAdapterInfo>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUAdapterInfo".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUAdapterInfo, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUAdapterInfo> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUAdapterInfo>, _can_gc: CanGc) -> DomRoot<D::GPUAdapterInfo>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUAdapterInfoMethods<D: DomTypes> {
    fn Vendor(&self, ) -> DOMString;
    fn Architecture(&self, ) -> DOMString;
    fn Device(&self, ) -> DOMString;
    fn Description(&self, ) -> DOMString;
    fn SubgroupMinSize(&self, ) -> u32;
    fn SubgroupMaxSize(&self, ) -> u32;
    fn IsFallbackAdapter(&self, ) -> bool;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"vendor".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { vendor_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"architecture".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { architecture_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"device".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { device_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"description".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { description_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"subgroupMinSize".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { subgroupMinSize_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"subgroupMaxSize".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { subgroupMaxSize_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"isFallbackAdapter".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { isFallbackAdapter_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUAdapterInfo".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUAdapterInfo), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUAdapterInfoPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUAdapterInfo() {\n    [native code]\n}",
        PrototypeList::ID::GPUAdapterInfo,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUAdapterInfo),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUAdapterInfo as usize].is_null());
    (*cache)[PrototypeList::ID::GPUAdapterInfo as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUAdapterInfo as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUAdapterInfo",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_vendor_getterinfo::<D>();
init_architecture_getterinfo::<D>();
init_device_getterinfo::<D>();
init_description_getterinfo::<D>();
init_subgroupMinSize_getterinfo::<D>();
init_subgroupMaxSize_getterinfo::<D>();
init_isFallbackAdapter_getterinfo::<D>();


            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUAdapterInfo_Binding


pub use self::GPUBindGroup_Binding::{Wrap as GPUBindGroupWrap, GPUBindGroupMethods, GetProtoObject as GPUBindGroupGetProtoObject, DefineDOMInterface as GPUBindGroupDefineDOMInterface};
pub mod GPUBindGroup_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBindGroup);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBindGroup);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBindGroup as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBindGroup as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUBindGroup>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUBindGroup>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUBindGroup".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUBindGroup, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUBindGroup> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUBindGroup>, _can_gc: CanGc) -> DomRoot<D::GPUBindGroup>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUBindGroupMethods<D: DomTypes> {
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUBindGroup".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUBindGroup), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUBindGroupPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUBindGroup() {\n    [native code]\n}",
        PrototypeList::ID::GPUBindGroup,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUBindGroup),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUBindGroup as usize].is_null());
    (*cache)[PrototypeList::ID::GPUBindGroup as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUBindGroup as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUBindGroup",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUBindGroup_Binding


pub use self::GPUBindGroupLayout_Binding::{Wrap as GPUBindGroupLayoutWrap, GPUBindGroupLayoutMethods, GetProtoObject as GPUBindGroupLayoutGetProtoObject, DefineDOMInterface as GPUBindGroupLayoutDefineDOMInterface};
pub mod GPUBindGroupLayout_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBindGroupLayout);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBindGroupLayout);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBindGroupLayout as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBindGroupLayout as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUBindGroupLayout>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUBindGroupLayout>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUBindGroupLayout".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUBindGroupLayout, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUBindGroupLayout> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUBindGroupLayout>, _can_gc: CanGc) -> DomRoot<D::GPUBindGroupLayout>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUBindGroupLayoutMethods<D: DomTypes> {
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUBindGroupLayout".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUBindGroupLayout), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUBindGroupLayoutPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUBindGroupLayout() {\n    [native code]\n}",
        PrototypeList::ID::GPUBindGroupLayout,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUBindGroupLayout),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUBindGroupLayout as usize].is_null());
    (*cache)[PrototypeList::ID::GPUBindGroupLayout as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUBindGroupLayout as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUBindGroupLayout",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUBindGroupLayout_Binding


pub use self::GPUBuffer_Binding::{Wrap as GPUBufferWrap, GPUBufferMethods, GetProtoObject as GPUBufferGetProtoObject, DefineDOMInterface as GPUBufferDefineDOMInterface};
pub mod GPUBuffer_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUBufferMapState;
use crate::codegen::GenericBindings::WebGPUBinding::GPUBufferMapStateValues;
use crate::import::module::*;

unsafe extern "C" fn get_size<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBuffer);
        let result: u64 = this.Size();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static size_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_size_getterinfo<D: DomTypes>() {
    size_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_size::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_usage<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBuffer);
        let result: u32 = this.Usage();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static usage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_usage_getterinfo<D: DomTypes>() {
    usage_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_usage::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_mapState<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBuffer);
        let result: GPUBufferMapState = this.MapState();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static mapState_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_mapState_getterinfo<D: DomTypes>() {
    mapState_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_mapState::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn mapAsync<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBuffer);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUBuffer.mapAsync\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: u64 = if args.get(1).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg2: Option<u64> = if args.get(2).is_undefined() {
            None
        } else {
            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }
            )
        };
        let result: Rc<D::Promise> = this.MapAsync(arg0, arg1, arg2, InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn mapAsync_promise_wrapper<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let ok = mapAsync::<D>(cx, _obj, this, args);
        if ok {
          return true;
        }
        return exception_to_promise(cx, (*args).rval(), CanGc::note());

    })());
    result
}


static mapAsync_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_mapAsync_methodinfo<D: DomTypes>() {
    mapAsync_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(mapAsync_promise_wrapper::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn getMappedRange<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBuffer);
        let args = &*args;
        let argc = args.argc_;
        let arg0: u64 = if args.get(0).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg1: Option<u64> = if args.get(1).is_undefined() {
            None
        } else {
            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }
            )
        };
        let result: Result<ArrayBuffer, Error> = this.GetMappedRange(SafeJSContext::from_ptr(cx.raw_cx()), arg0, arg1, CanGc::note());
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static getMappedRange_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_getMappedRange_methodinfo<D: DomTypes>() {
    getMappedRange_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(getMappedRange::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn unmap<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBuffer);
        let args = &*args;
        let argc = args.argc_;
        let result: () = this.Unmap();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static unmap_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_unmap_methodinfo<D: DomTypes>() {
    unmap_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(unmap::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn destroy<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBuffer);
        let args = &*args;
        let argc = args.argc_;
        let result: () = this.Destroy();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static destroy_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_destroy_methodinfo<D: DomTypes>() {
    destroy_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(destroy::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBuffer);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUBuffer);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUBuffer>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUBuffer>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUBuffer".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUBuffer, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUBuffer> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUBuffer>, _can_gc: CanGc) -> DomRoot<D::GPUBuffer>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUBufferMethods<D: DomTypes> {
    fn Size(&self, ) -> u64;
    fn Usage(&self, ) -> u32;
    fn MapState(&self, ) -> GPUBufferMapState;
    fn MapAsync(&self, r#mode: u32, r#offset: u64, r#size: Option<u64>, r#_comp: InRealm, r#_can_gc: CanGc) -> Rc<D::Promise>;
    fn GetMappedRange(&self, r#cx: SafeJSContext, r#offset: u64, r#size: Option<u64>, r#_can_gc: CanGc) -> Fallible<ArrayBuffer>;
    fn Unmap(&self, );
    fn Destroy(&self, );
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"mapAsync".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { mapAsync_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"getMappedRange".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getMappedRange_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"unmap".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { unmap_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"destroy".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { destroy_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"size".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { size_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"usage".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { usage_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"mapState".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { mapState_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUBuffer".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUBuffer), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUBufferPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUBuffer() {\n    [native code]\n}",
        PrototypeList::ID::GPUBuffer,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUBuffer),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUBuffer as usize].is_null());
    (*cache)[PrototypeList::ID::GPUBuffer as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUBuffer as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUBuffer",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUBuffer_Binding::init_mapAsync_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUBuffer_Binding::init_getMappedRange_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUBuffer_Binding::init_unmap_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUBuffer_Binding::init_destroy_methodinfo::<D>();
            init_size_getterinfo::<D>();
init_usage_getterinfo::<D>();
init_mapState_getterinfo::<D>();
init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUBuffer_Binding


pub use self::GPUBufferUsage_Binding::{GPUBufferUsageConstants, GetConstructorObject as GPUBufferUsageGetConstructorObject, DefineDOMInterface as GPUBufferUsageDefineDOMInterface};
pub mod GPUBufferUsage_Binding {
use crate::import::module::*;

pub mod GPUBufferUsageConstants {
    pub const MAP_READ: u32 = 1;
    pub const MAP_WRITE: u32 = 2;
    pub const COPY_SRC: u32 = 4;
    pub const COPY_DST: u32 = 8;
    pub const INDEX: u32 = 16;
    pub const VERTEX: u32 = 32;
    pub const UNIFORM: u32 = 64;
    pub const STORAGE: u32 = 128;
    pub const INDIRECT: u32 = 256;
    pub const QUERY_RESOLVE: u32 = 512;
} // mod GPUBufferUsageConstants
pub trait GPUBufferUsageMethods<D: DomTypes> {
}
static sConstants_specs: ThreadUnsafeOnceLock<&[&[ConstantSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_specs<D: DomTypes>() {
    sConstants_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    ConstantSpec { name: c"MAP_READ", value: ConstantVal::Uint(1) },
    ConstantSpec { name: c"MAP_WRITE", value: ConstantVal::Uint(2) },
    ConstantSpec { name: c"COPY_SRC", value: ConstantVal::Uint(4) },
    ConstantSpec { name: c"COPY_DST", value: ConstantVal::Uint(8) },
    ConstantSpec { name: c"INDEX", value: ConstantVal::Uint(16) },
    ConstantSpec { name: c"VERTEX", value: ConstantVal::Uint(32) },
    ConstantSpec { name: c"UNIFORM", value: ConstantVal::Uint(64) },
    ConstantSpec { name: c"STORAGE", value: ConstantVal::Uint(128) },
    ConstantSpec { name: c"INDIRECT", value: ConstantVal::Uint(256) },
    ConstantSpec { name: c"QUERY_RESOLVE", value: ConstantVal::Uint(512) }]))[..]
])));
}static sConstants: ThreadUnsafeOnceLock<&[Guard<&[ConstantSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_prefs<D: DomTypes>() {
    sConstants.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[0])])));
}

static NAMESPACE_OBJECT_CLASS: NamespaceObjectClass = unsafe {
    NamespaceObjectClass::new(c"Object")
};

pub fn GetConstructorObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface object for this class.  This will create the object as
       needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::GPUBufferUsage), CreateInterfaceObjects::<D>, rval)
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::GPUBufferUsage),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let proto = JS_NewPlainObject(cx.raw_cx()));
    assert!(!proto.is_null());
    rooted!(&in(cx) let mut namespace = ptr::null_mut::<JSObject>());
    create_namespace_object::<D>(cx, global, proto.handle(), &NAMESPACE_OBJECT_CLASS,
                            &[], sConstants.get(), c"GPUBufferUsage", namespace.handle_mut());
    assert!(!namespace.is_null());
    assert!((*cache)[PrototypeList::Constructor::GPUBufferUsage as usize].is_null());
    (*cache)[PrototypeList::Constructor::GPUBufferUsage as usize] = namespace.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::GPUBufferUsage as isize),
                                  ptr::null_mut(),
                                  namespace.get());

}


        pub(crate) fn init_statics<D: DomTypes>() {






            init_sConstants_specs::<D>();
init_sConstants_prefs::<D>();
        }
        } // mod GPUBufferUsage_Binding


pub use self::GPUColorWrite_Binding::{GPUColorWriteConstants, Wrap as GPUColorWriteWrap, GetProtoObject as GPUColorWriteGetProtoObject, DefineDOMInterface as GPUColorWriteDefineDOMInterface};
pub mod GPUColorWrite_Binding {
use crate::import::module::*;

unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUColorWrite>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUColorWrite>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}

pub mod GPUColorWriteConstants {
    pub const RED: u32 = 1;
    pub const GREEN: u32 = 2;
    pub const BLUE: u32 = 4;
    pub const ALPHA: u32 = 8;
    pub const ALL: u32 = 15;
} // mod GPUColorWriteConstants

static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUColorWrite".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUColorWrite, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUColorWrite> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUColorWrite>, _can_gc: CanGc) -> DomRoot<D::GPUColorWrite>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUColorWriteMethods<D: DomTypes> {
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUColorWrite".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[0])])));
}static sConstants_specs: ThreadUnsafeOnceLock<&[&[ConstantSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_specs<D: DomTypes>() {
    sConstants_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    ConstantSpec { name: c"RED", value: ConstantVal::Uint(1) },
    ConstantSpec { name: c"GREEN", value: ConstantVal::Uint(2) },
    ConstantSpec { name: c"BLUE", value: ConstantVal::Uint(4) },
    ConstantSpec { name: c"ALPHA", value: ConstantVal::Uint(8) },
    ConstantSpec { name: c"ALL", value: ConstantVal::Uint(15) }]))[..]
])));
}static sConstants: ThreadUnsafeOnceLock<&[Guard<&[ConstantSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_prefs<D: DomTypes>() {
    sConstants.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[0])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUColorWrite), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUColorWritePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUColorWrite() {\n    [native code]\n}",
        PrototypeList::ID::GPUColorWrite,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUColorWrite),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      sConstants.get(),
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUColorWrite as usize].is_null());
    (*cache)[PrototypeList::ID::GPUColorWrite as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUColorWrite as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        sConstants.get(),
                                        prototype.handle(),
                                        c"GPUColorWrite",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();




            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
init_sConstants_specs::<D>();
init_sConstants_prefs::<D>();
        }
        } // mod GPUColorWrite_Binding


pub use self::GPUCommandBuffer_Binding::{Wrap as GPUCommandBufferWrap, GPUCommandBufferMethods, GetProtoObject as GPUCommandBufferGetProtoObject, DefineDOMInterface as GPUCommandBufferDefineDOMInterface};
pub mod GPUCommandBuffer_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandBuffer);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandBuffer);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandBuffer as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUCommandBuffer>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUCommandBuffer>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUCommandBuffer".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUCommandBuffer, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUCommandBuffer> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUCommandBuffer>, _can_gc: CanGc) -> DomRoot<D::GPUCommandBuffer>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUCommandBufferMethods<D: DomTypes> {
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUCommandBuffer".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUCommandBuffer), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUCommandBufferPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUCommandBuffer() {\n    [native code]\n}",
        PrototypeList::ID::GPUCommandBuffer,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUCommandBuffer),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUCommandBuffer as usize].is_null());
    (*cache)[PrototypeList::ID::GPUCommandBuffer as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUCommandBuffer as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUCommandBuffer",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUCommandBuffer_Binding


pub use self::GPUCommandEncoder_Binding::{Wrap as GPUCommandEncoderWrap, GPUCommandEncoderMethods, GetProtoObject as GPUCommandEncoderGetProtoObject, DefineDOMInterface as GPUCommandEncoderDefineDOMInterface};
pub mod GPUCommandEncoder_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUCommandBufferDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUComputePassDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUExtent3DDict;
use crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyBuffer;
use crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture;
use crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassColorAttachment;
use crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassDepthStencilAttachment;
use crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureAspect;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureAspectValues;
use crate::import::module::*;

unsafe extern "C" fn beginComputePass<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandEncoder);
        let args = &*args;
        let argc = args.argc_;
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUComputePassDescriptor = if args.get(0).is_undefined() {
            crate::codegen::GenericBindings::WebGPUBinding::GPUComputePassDescriptor::empty()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: DomRoot<D::GPUComputePassEncoder> = this.BeginComputePass(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static beginComputePass_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_beginComputePass_methodinfo<D: DomTypes>() {
    beginComputePass_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(beginComputePass::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn beginRenderPass<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUCommandEncoder.beginRenderPass\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassDescriptor<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<DomRoot<D::GPURenderPassEncoder>, Error> = this.BeginRenderPass(&arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static beginRenderPass_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_beginRenderPass_methodinfo<D: DomTypes>() {
    beginRenderPass_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(beginRenderPass::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn copyBufferToBuffer<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 5 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUCommandEncoder.copyBufferToBuffer\".");
            return false;
        }
        let arg0: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(2)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(2)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg3: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg4: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.CopyBufferToBuffer(&arg0, arg1, &arg2, arg3, arg4);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static copyBufferToBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_copyBufferToBuffer_methodinfo<D: DomTypes>() {
    copyBufferToBuffer_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(copyBufferToBuffer::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn copyBufferToTexture<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 3 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUCommandEncoder.copyBufferToTexture\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyBuffer<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<(), Error> = this.CopyBufferToTexture(&arg0, &arg1, arg2);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static copyBufferToTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_copyBufferToTexture_methodinfo<D: DomTypes>() {
    copyBufferToTexture_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(copyBufferToTexture::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn copyTextureToBuffer<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 3 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUCommandEncoder.copyTextureToBuffer\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyBuffer<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<(), Error> = this.CopyTextureToBuffer(&arg0, &arg1, arg2);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static copyTextureToBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_copyTextureToBuffer_methodinfo<D: DomTypes>() {
    copyTextureToBuffer_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(copyTextureToBuffer::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn copyTextureToTexture<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 3 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUCommandEncoder.copyTextureToTexture\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<(), Error> = this.CopyTextureToTexture(&arg0, &arg1, arg2);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static copyTextureToTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_copyTextureToTexture_methodinfo<D: DomTypes>() {
    copyTextureToTexture_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(copyTextureToTexture::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn finish<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandEncoder);
        let args = &*args;
        let argc = args.argc_;
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUCommandBufferDescriptor = if args.get(0).is_undefined() {
            crate::codegen::GenericBindings::WebGPUBinding::GPUCommandBufferDescriptor::empty()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: DomRoot<D::GPUCommandBuffer> = this.Finish(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static finish_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_finish_methodinfo<D: DomTypes>() {
    finish_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(finish::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandEncoder);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCommandEncoder);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCommandEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUCommandEncoder>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUCommandEncoder>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUCommandEncoder".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUCommandEncoder, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUCommandEncoder> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUCommandEncoder>, _can_gc: CanGc) -> DomRoot<D::GPUCommandEncoder>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUCommandEncoderMethods<D: DomTypes> {
    fn BeginComputePass(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUComputePassDescriptor) -> DomRoot<D::GPUComputePassEncoder>;
    fn BeginRenderPass(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassDescriptor<D>) -> Fallible<DomRoot<D::GPURenderPassEncoder>>;
    fn CopyBufferToBuffer(&self, r#source: &D::GPUBuffer, r#sourceOffset: u64, r#destination: &D::GPUBuffer, r#destinationOffset: u64, r#size: u64);
    fn CopyBufferToTexture(&self, r#source: &crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyBuffer<D>, r#destination: &crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D>, r#copySize: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict) -> Fallible<()>;
    fn CopyTextureToBuffer(&self, r#source: &crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D>, r#destination: &crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyBuffer<D>, r#copySize: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict) -> Fallible<()>;
    fn CopyTextureToTexture(&self, r#source: &crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D>, r#destination: &crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D>, r#copySize: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict) -> Fallible<()>;
    fn Finish(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUCommandBufferDescriptor) -> DomRoot<D::GPUCommandBuffer>;
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"beginComputePass".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { beginComputePass_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"beginRenderPass".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { beginRenderPass_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"copyBufferToBuffer".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { copyBufferToBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 5,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"copyBufferToTexture".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { copyBufferToTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 3,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"copyTextureToBuffer".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { copyTextureToBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 3,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"copyTextureToTexture".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { copyTextureToTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 3,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"finish".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { finish_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUCommandEncoder".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUCommandEncoder), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUCommandEncoderPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUCommandEncoder() {\n    [native code]\n}",
        PrototypeList::ID::GPUCommandEncoder,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUCommandEncoder),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUCommandEncoder as usize].is_null());
    (*cache)[PrototypeList::ID::GPUCommandEncoder as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUCommandEncoder as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUCommandEncoder",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoder_Binding::init_beginComputePass_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoder_Binding::init_beginRenderPass_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoder_Binding::init_copyBufferToBuffer_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoder_Binding::init_copyBufferToTexture_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoder_Binding::init_copyTextureToBuffer_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoder_Binding::init_copyTextureToTexture_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoder_Binding::init_finish_methodinfo::<D>();
            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUCommandEncoder_Binding


pub use self::GPUCompilationInfo_Binding::{Wrap as GPUCompilationInfoWrap, GPUCompilationInfoMethods, GetProtoObject as GPUCompilationInfoGetProtoObject, DefineDOMInterface as GPUCompilationInfoDefineDOMInterface};
pub mod GPUCompilationInfo_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_messages<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCompilationInfo);
        rooted!(&in(cx) let mut retval: JSVal);
        let result: () = this.Messages(SafeJSContext::from_ptr(cx.raw_cx()), CanGc::note(), retval.handle_mut());

        (retval).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static messages_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_messages_getterinfo<D: DomTypes>() {
    messages_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_messages::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCompilationInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNKNOWN as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUCompilationInfo>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUCompilationInfo>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUCompilationInfo".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUCompilationInfo, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUCompilationInfo> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUCompilationInfo>, _can_gc: CanGc) -> DomRoot<D::GPUCompilationInfo>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUCompilationInfoMethods<D: DomTypes> {
    fn Messages(&self, r#cx: SafeJSContext, r#_can_gc: CanGc, r#retval: MutableHandleValue);
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"messages".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { messages_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUCompilationInfo".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUCompilationInfo), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUCompilationInfoPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUCompilationInfo() {\n    [native code]\n}",
        PrototypeList::ID::GPUCompilationInfo,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUCompilationInfo),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUCompilationInfo as usize].is_null());
    (*cache)[PrototypeList::ID::GPUCompilationInfo as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUCompilationInfo as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUCompilationInfo",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_messages_getterinfo::<D>();


            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUCompilationInfo_Binding


pub use self::GPUCompilationMessage_Binding::{Wrap as GPUCompilationMessageWrap, GPUCompilationMessageMethods, GetProtoObject as GPUCompilationMessageGetProtoObject, DefineDOMInterface as GPUCompilationMessageDefineDOMInterface};
pub mod GPUCompilationMessage_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUCompilationMessageType;
use crate::codegen::GenericBindings::WebGPUBinding::GPUCompilationMessageTypeValues;
use crate::import::module::*;

unsafe extern "C" fn get_message<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCompilationMessage);
        let result: DOMString = this.Message();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static message_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_message_getterinfo<D: DomTypes>() {
    message_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_message::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCompilationMessage as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_type<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCompilationMessage);
        let result: GPUCompilationMessageType = this.Type();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static type_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_type_getterinfo<D: DomTypes>() {
    type_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_type::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCompilationMessage as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_lineNum<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCompilationMessage);
        let result: u64 = this.LineNum();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static lineNum_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_lineNum_getterinfo<D: DomTypes>() {
    lineNum_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_lineNum::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCompilationMessage as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_linePos<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCompilationMessage);
        let result: u64 = this.LinePos();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static linePos_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_linePos_getterinfo<D: DomTypes>() {
    linePos_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_linePos::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCompilationMessage as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_offset<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCompilationMessage);
        let result: u64 = this.Offset();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static offset_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_offset_getterinfo<D: DomTypes>() {
    offset_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_offset::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCompilationMessage as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_length<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUCompilationMessage);
        let result: u64 = this.Length();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static length_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_length_getterinfo<D: DomTypes>() {
    length_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_length::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUCompilationMessage as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUCompilationMessage>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUCompilationMessage>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUCompilationMessage".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUCompilationMessage, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUCompilationMessage> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUCompilationMessage>, _can_gc: CanGc) -> DomRoot<D::GPUCompilationMessage>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUCompilationMessageMethods<D: DomTypes> {
    fn Message(&self, ) -> DOMString;
    fn Type(&self, ) -> GPUCompilationMessageType;
    fn LineNum(&self, ) -> u64;
    fn LinePos(&self, ) -> u64;
    fn Offset(&self, ) -> u64;
    fn Length(&self, ) -> u64;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"message".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { message_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"type".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { type_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"lineNum".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { lineNum_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"linePos".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { linePos_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"offset".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { offset_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"length".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { length_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUCompilationMessage".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUCompilationMessage), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUCompilationMessagePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUCompilationMessage() {\n    [native code]\n}",
        PrototypeList::ID::GPUCompilationMessage,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUCompilationMessage),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUCompilationMessage as usize].is_null());
    (*cache)[PrototypeList::ID::GPUCompilationMessage as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUCompilationMessage as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUCompilationMessage",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_message_getterinfo::<D>();
init_type_getterinfo::<D>();
init_lineNum_getterinfo::<D>();
init_linePos_getterinfo::<D>();
init_offset_getterinfo::<D>();
init_length_getterinfo::<D>();


            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUCompilationMessage_Binding


pub use self::GPUComputePassEncoder_Binding::{Wrap as GPUComputePassEncoderWrap, GPUComputePassEncoderMethods, GetProtoObject as GPUComputePassEncoderGetProtoObject, DefineDOMInterface as GPUComputePassEncoderDefineDOMInterface};
pub mod GPUComputePassEncoder_Binding {
use crate::import::module::*;

unsafe extern "C" fn setPipeline<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUComputePassEncoder.setPipeline\".");
            return false;
        }
        let arg0: DomRoot<D::GPUComputePipeline> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUComputePipeline.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let result: () = this.SetPipeline(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setPipeline_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setPipeline_methodinfo<D: DomTypes>() {
    setPipeline_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setPipeline::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn dispatchWorkgroups<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUComputePassEncoder.dispatchWorkgroups\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: u32 = if args.get(1).is_undefined() {
            1
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg2: u32 = if args.get(2).is_undefined() {
            1
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.DispatchWorkgroups(arg0, arg1, arg2);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static dispatchWorkgroups_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_dispatchWorkgroups_methodinfo<D: DomTypes>() {
    dispatchWorkgroups_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(dispatchWorkgroups::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn dispatchWorkgroupsIndirect<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUComputePassEncoder.dispatchWorkgroupsIndirect\".");
            return false;
        }
        let arg0: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.DispatchWorkgroupsIndirect(&arg0, arg1);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static dispatchWorkgroupsIndirect_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_dispatchWorkgroupsIndirect_methodinfo<D: DomTypes>() {
    dispatchWorkgroupsIndirect_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(dispatchWorkgroupsIndirect::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn end<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePassEncoder);
        let args = &*args;
        let argc = args.argc_;
        let result: () = this.End();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static end_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_end_methodinfo<D: DomTypes>() {
    end_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(end::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePassEncoder);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePassEncoder);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setBindGroup<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUComputePassEncoder.setBindGroup\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: DomRoot<D::GPUBindGroup> = if HandleValue::from_raw(args.get(1)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBindGroup.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg2: Vec<u32> = if args.get(2).is_undefined() {
            Vec::new()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.SetBindGroup(arg0, &arg1, arg2);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setBindGroup_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setBindGroup_methodinfo<D: DomTypes>() {
    setBindGroup_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setBindGroup::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUComputePassEncoder>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUComputePassEncoder>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUComputePassEncoder".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUComputePassEncoder, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUComputePassEncoder> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUComputePassEncoder>, _can_gc: CanGc) -> DomRoot<D::GPUComputePassEncoder>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUComputePassEncoderMethods<D: DomTypes> {
    fn SetPipeline(&self, r#pipeline: &D::GPUComputePipeline);
    fn DispatchWorkgroups(&self, r#x: u32, r#y: u32, r#z: u32);
    fn DispatchWorkgroupsIndirect(&self, r#indirectBuffer: &D::GPUBuffer, r#indirectOffset: u64);
    fn End(&self, );
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
    fn SetBindGroup(&self, r#index: u32, r#bindGroup: &D::GPUBindGroup, r#dynamicOffsets: Vec<u32>);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setPipeline".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setPipeline_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"dispatchWorkgroups".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { dispatchWorkgroups_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"dispatchWorkgroupsIndirect".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { dispatchWorkgroupsIndirect_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"end".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { end_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setBindGroup".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setBindGroup_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUComputePassEncoder".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUComputePassEncoder), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUComputePassEncoderPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUComputePassEncoder() {\n    [native code]\n}",
        PrototypeList::ID::GPUComputePassEncoder,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUComputePassEncoder),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUComputePassEncoder as usize].is_null());
    (*cache)[PrototypeList::ID::GPUComputePassEncoder as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUComputePassEncoder as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUComputePassEncoder",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUComputePassEncoder_Binding::init_setPipeline_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUComputePassEncoder_Binding::init_dispatchWorkgroups_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUComputePassEncoder_Binding::init_dispatchWorkgroupsIndirect_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUComputePassEncoder_Binding::init_end_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUComputePassEncoder_Binding::init_setBindGroup_methodinfo::<D>();
            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUComputePassEncoder_Binding


pub use self::GPUComputePipeline_Binding::{Wrap as GPUComputePipelineWrap, GPUComputePipelineMethods, GetProtoObject as GPUComputePipelineGetProtoObject, DefineDOMInterface as GPUComputePipelineDefineDOMInterface};
pub mod GPUComputePipeline_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePipeline);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePipeline);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePipeline as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePipeline as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn getBindGroupLayout<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUComputePipeline);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUComputePipeline.getBindGroupLayout\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<DomRoot<D::GPUBindGroupLayout>, Error> = this.GetBindGroupLayout(arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static getBindGroupLayout_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_getBindGroupLayout_methodinfo<D: DomTypes>() {
    getBindGroupLayout_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(getBindGroupLayout::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUComputePipeline as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUComputePipeline>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUComputePipeline>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUComputePipeline".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUComputePipeline, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUComputePipeline> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUComputePipeline>, _can_gc: CanGc) -> DomRoot<D::GPUComputePipeline>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUComputePipelineMethods<D: DomTypes> {
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
    fn GetBindGroupLayout(&self, r#index: u32) -> Fallible<DomRoot<D::GPUBindGroupLayout>>;
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"getBindGroupLayout".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getBindGroupLayout_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUComputePipeline".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUComputePipeline), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUComputePipelinePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUComputePipeline() {\n    [native code]\n}",
        PrototypeList::ID::GPUComputePipeline,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUComputePipeline),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUComputePipeline as usize].is_null());
    (*cache)[PrototypeList::ID::GPUComputePipeline as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUComputePipeline as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUComputePipeline",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUComputePipeline_Binding::init_getBindGroupLayout_methodinfo::<D>();
            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUComputePipeline_Binding


pub use self::GPUDevice_Binding::{Wrap as GPUDeviceWrap, GPUDeviceMethods, GetProtoObject as GPUDeviceGetProtoObject, DefineDOMInterface as GPUDeviceDefineDOMInterface};
pub mod GPUDevice_Binding {
use crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull;
use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
use crate::codegen::GenericBindings::WebGPUBinding::GPUAddressMode;
use crate::codegen::GenericBindings::WebGPUBinding::GPUAddressModeValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupEntry;
use crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupLayoutDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupLayoutEntry;
use crate::codegen::GenericBindings::WebGPUBinding::GPUBufferDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoderDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUCompareFunction;
use crate::codegen::GenericBindings::WebGPUBinding::GPUCompareFunctionValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPUComputePipelineDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUDepthStencilState;
use crate::codegen::GenericBindings::WebGPUBinding::GPUErrorFilter;
use crate::codegen::GenericBindings::WebGPUBinding::GPUErrorFilterValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPUFilterMode;
use crate::codegen::GenericBindings::WebGPUBinding::GPUFilterModeValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPUFragmentState;
use crate::codegen::GenericBindings::WebGPUBinding::GPUMultisampleState;
use crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineLayoutDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUPrimitiveState;
use crate::codegen::GenericBindings::WebGPUBinding::GPUProgrammableStage;
use crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoderDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPURenderPipelineDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUSamplerDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUShaderModuleDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureDimension;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureDimensionValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureFormat;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureFormatValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPUVertexState;
use crate::import::module::*;

unsafe extern "C" fn get_features<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let result: DomRoot<D::GPUSupportedFeatures> = this.Features();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static features_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_features_getterinfo<D: DomTypes>() {
    features_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_features::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasNone as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            true,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_limits<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let result: DomRoot<D::GPUSupportedLimits> = this.Limits();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static limits_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_limits_getterinfo<D: DomTypes>() {
    limits_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_limits::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasNone as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            true,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_adapterInfo<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let result: DomRoot<D::GPUAdapterInfo> = this.AdapterInfo();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static adapterInfo_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_adapterInfo_getterinfo<D: DomTypes>() {
    adapterInfo_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_adapterInfo::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasNone as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            true,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_queue<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let result: DomRoot<D::GPUQueue> = this.GetQueue();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static queue_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_queue_getterinfo<D: DomTypes>() {
    queue_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_queue::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasNone as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            true,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn destroy<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;
        let result: () = this.Destroy();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static destroy_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_destroy_methodinfo<D: DomTypes>() {
    destroy_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(destroy::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createBuffer<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createBuffer\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUBufferDescriptor = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<DomRoot<D::GPUBuffer>, Error> = this.CreateBuffer(&arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createBuffer_methodinfo<D: DomTypes>() {
    createBuffer_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createBuffer::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createTexture<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createTexture\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUTextureDescriptor = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<DomRoot<D::GPUTexture>, Error> = this.CreateTexture(&arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createTexture_methodinfo<D: DomTypes>() {
    createTexture_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createTexture::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createSampler<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUSamplerDescriptor = if args.get(0).is_undefined() {
            crate::codegen::GenericBindings::WebGPUBinding::GPUSamplerDescriptor::empty()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: DomRoot<D::GPUSampler> = this.CreateSampler(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createSampler_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createSampler_methodinfo<D: DomTypes>() {
    createSampler_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createSampler::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createBindGroupLayout<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createBindGroupLayout\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupLayoutDescriptor = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<DomRoot<D::GPUBindGroupLayout>, Error> = this.CreateBindGroupLayout(&arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createBindGroupLayout_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createBindGroupLayout_methodinfo<D: DomTypes>() {
    createBindGroupLayout_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createBindGroupLayout::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createPipelineLayout<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createPipelineLayout\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineLayoutDescriptor<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: DomRoot<D::GPUPipelineLayout> = this.CreatePipelineLayout(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createPipelineLayout_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createPipelineLayout_methodinfo<D: DomTypes>() {
    createPipelineLayout_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createPipelineLayout::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createBindGroup<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createBindGroup\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupDescriptor<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: DomRoot<D::GPUBindGroup> = this.CreateBindGroup(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createBindGroup_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createBindGroup_methodinfo<D: DomTypes>() {
    createBindGroup_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createBindGroup::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createShaderModule<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createShaderModule\".");
            return false;
        }
        let arg0: RootedTraceableBox<crate::codegen::GenericBindings::WebGPUBinding::GPUShaderModuleDescriptor> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: DomRoot<D::GPUShaderModule> = this.CreateShaderModule(arg0, InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createShaderModule_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createShaderModule_methodinfo<D: DomTypes>() {
    createShaderModule_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createShaderModule::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createComputePipeline<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createComputePipeline\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUComputePipelineDescriptor<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: DomRoot<D::GPUComputePipeline> = this.CreateComputePipeline(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createComputePipeline_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createComputePipeline_methodinfo<D: DomTypes>() {
    createComputePipeline_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createComputePipeline::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createRenderPipeline<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createRenderPipeline\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPURenderPipelineDescriptor<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<DomRoot<D::GPURenderPipeline>, Error> = this.CreateRenderPipeline(&arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createRenderPipeline_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createRenderPipeline_methodinfo<D: DomTypes>() {
    createRenderPipeline_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createRenderPipeline::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createComputePipelineAsync<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createComputePipelineAsync\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUComputePipelineDescriptor<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Rc<D::Promise> = this.CreateComputePipelineAsync(&arg0, InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn createComputePipelineAsync_promise_wrapper<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let ok = createComputePipelineAsync::<D>(cx, _obj, this, args);
        if ok {
          return true;
        }
        return exception_to_promise(cx, (*args).rval(), CanGc::note());

    })());
    result
}


static createComputePipelineAsync_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createComputePipelineAsync_methodinfo<D: DomTypes>() {
    createComputePipelineAsync_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createComputePipelineAsync_promise_wrapper::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createRenderPipelineAsync<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createRenderPipelineAsync\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPURenderPipelineDescriptor<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<Rc<D::Promise>, Error> = this.CreateRenderPipelineAsync(&arg0, InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn createRenderPipelineAsync_promise_wrapper<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let ok = createRenderPipelineAsync::<D>(cx, _obj, this, args);
        if ok {
          return true;
        }
        return exception_to_promise(cx, (*args).rval(), CanGc::note());

    })());
    result
}


static createRenderPipelineAsync_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createRenderPipelineAsync_methodinfo<D: DomTypes>() {
    createRenderPipelineAsync_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createRenderPipelineAsync_promise_wrapper::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createCommandEncoder<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoderDescriptor = if args.get(0).is_undefined() {
            crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoderDescriptor::empty()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: DomRoot<D::GPUCommandEncoder> = this.CreateCommandEncoder(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createCommandEncoder_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createCommandEncoder_methodinfo<D: DomTypes>() {
    createCommandEncoder_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createCommandEncoder::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn createRenderBundleEncoder<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.createRenderBundleEncoder\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoderDescriptor = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<DomRoot<D::GPURenderBundleEncoder>, Error> = this.CreateRenderBundleEncoder(&arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createRenderBundleEncoder_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createRenderBundleEncoder_methodinfo<D: DomTypes>() {
    createRenderBundleEncoder_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createRenderBundleEncoder::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_lost<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let result: Rc<D::Promise> = this.Lost();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn get_lost_promise_wrapper<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let ok = get_lost::<D>(cx, _obj, this, args);
        if ok {
          return true;
        }
        return exception_to_promise(cx, args.rval(), CanGc::note());

    })());
    result
}


static lost_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_lost_getterinfo<D: DomTypes>() {
    lost_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_lost_promise_wrapper::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn pushErrorScope<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUDevice.pushErrorScope\".");
            return false;
        }
        let arg0: GPUErrorFilter = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error); return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.PushErrorScope(arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static pushErrorScope_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_pushErrorScope_methodinfo<D: DomTypes>() {
    pushErrorScope_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(pushErrorScope::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn popErrorScope<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let args = &*args;
        let argc = args.argc_;
        let result: Rc<D::Promise> = this.PopErrorScope(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()))), CanGc::note());

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn popErrorScope_promise_wrapper<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let ok = popErrorScope::<D>(cx, _obj, this, args);
        if ok {
          return true;
        }
        return exception_to_promise(cx, (*args).rval(), CanGc::note());

    })());
    result
}


static popErrorScope_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_popErrorScope_methodinfo<D: DomTypes>() {
    popErrorScope_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(popErrorScope_promise_wrapper::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_onuncapturederror<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let result: Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>> = this.GetOnuncapturederror();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_onuncapturederror<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let arg0: Option<Rc<EventHandlerNonNull<D>>> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            Some(EventHandlerNonNull::<D>::new(SafeJSContext::from_ptr(cx.raw_cx()), HandleValue::from_raw(args.get(0)).get().to_object()))
        } else {
            None
        };
        let result: () = this.SetOnuncapturederror(arg0);

        true
    });
    result
}


static onuncapturederror_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_onuncapturederror_getterinfo<D: DomTypes>() {
    onuncapturederror_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_onuncapturederror::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNKNOWN as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static onuncapturederror_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_onuncapturederror_setterinfo<D: DomTypes>() {
    onuncapturederror_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_onuncapturederror::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDevice);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDevice as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUDevice>(obj).unwrap();
        finalize_weak_referenceable(obj, this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUDevice>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUDevice".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((2) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(2) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::EventTarget, PrototypeList::ID::GPUDevice, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 1,
    type_id: crate::codegen::InheritTypes::TopTypeId { eventtarget: (crate::codegen::InheritTypes::EventTargetTypeId::GPUDevice) },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUDevice> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUDevice>, _can_gc: CanGc) -> DomRoot<D::GPUDevice>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let val = PrivateValue(ptr::null());
    JS_SetReservedSlot(obj.get(), DOM_WEAK_SLOT, &val);

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUDeviceMethods<D: DomTypes> {
    fn Features(&self, ) -> DomRoot<D::GPUSupportedFeatures>;
    fn Limits(&self, ) -> DomRoot<D::GPUSupportedLimits>;
    fn AdapterInfo(&self, ) -> DomRoot<D::GPUAdapterInfo>;
    fn GetQueue(&self, ) -> DomRoot<D::GPUQueue>;
    fn Destroy(&self, );
    fn CreateBuffer(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUBufferDescriptor) -> Fallible<DomRoot<D::GPUBuffer>>;
    fn CreateTexture(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUTextureDescriptor) -> Fallible<DomRoot<D::GPUTexture>>;
    fn CreateSampler(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUSamplerDescriptor) -> DomRoot<D::GPUSampler>;
    fn CreateBindGroupLayout(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupLayoutDescriptor) -> Fallible<DomRoot<D::GPUBindGroupLayout>>;
    fn CreatePipelineLayout(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineLayoutDescriptor<D>) -> DomRoot<D::GPUPipelineLayout>;
    fn CreateBindGroup(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUBindGroupDescriptor<D>) -> DomRoot<D::GPUBindGroup>;
    fn CreateShaderModule(&self, r#descriptor: RootedTraceableBox<crate::codegen::GenericBindings::WebGPUBinding::GPUShaderModuleDescriptor>, r#_comp: InRealm, r#_can_gc: CanGc) -> DomRoot<D::GPUShaderModule>;
    fn CreateComputePipeline(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUComputePipelineDescriptor<D>) -> DomRoot<D::GPUComputePipeline>;
    fn CreateRenderPipeline(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPURenderPipelineDescriptor<D>) -> Fallible<DomRoot<D::GPURenderPipeline>>;
    fn CreateComputePipelineAsync(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUComputePipelineDescriptor<D>, r#_comp: InRealm, r#_can_gc: CanGc) -> Rc<D::Promise>;
    fn CreateRenderPipelineAsync(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPURenderPipelineDescriptor<D>, r#_comp: InRealm, r#_can_gc: CanGc) -> Fallible<Rc<D::Promise>>;
    fn CreateCommandEncoder(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUCommandEncoderDescriptor) -> DomRoot<D::GPUCommandEncoder>;
    fn CreateRenderBundleEncoder(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoderDescriptor) -> Fallible<DomRoot<D::GPURenderBundleEncoder>>;
    fn Lost(&self, ) -> Rc<D::Promise>;
    fn PushErrorScope(&self, r#filter: GPUErrorFilter);
    fn PopErrorScope(&self, r#_comp: InRealm, r#_can_gc: CanGc) -> Rc<D::Promise>;
    fn GetOnuncapturederror(&self, ) -> Option<Rc<crate::codegen::GenericBindings::EventHandlerBinding::EventHandlerNonNull<D>>>;
    fn SetOnuncapturederror(&self, r#value: Option<Rc<EventHandlerNonNull<D>>>);
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"destroy".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { destroy_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createBuffer".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createTexture".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createSampler".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createSampler_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createBindGroupLayout".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createBindGroupLayout_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createPipelineLayout".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createPipelineLayout_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createBindGroup".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createBindGroup_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createShaderModule".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createShaderModule_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createComputePipeline".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createComputePipeline_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createRenderPipeline".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createRenderPipeline_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createComputePipelineAsync".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { createComputePipelineAsync_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createRenderPipelineAsync".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { createRenderPipelineAsync_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createCommandEncoder".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createCommandEncoder_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createRenderBundleEncoder".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createRenderBundleEncoder_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"pushErrorScope".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { pushErrorScope_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"popErrorScope".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { popErrorScope_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"features".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { features_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"limits".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { limits_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"adapterInfo".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { adapterInfo_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"queue".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { queue_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"lost".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<true>), info: unsafe { lost_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"onuncapturederror".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { onuncapturederror_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { onuncapturederror_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUDevice".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUDevice), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUDevicePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUDevice() {\n    [native code]\n}",
        PrototypeList::ID::GPUDevice,
        1,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUDevice),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    EventTarget_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUDevice as usize].is_null());
    (*cache)[PrototypeList::ID::GPUDevice as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUDevice as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());

    EventTarget_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUDevice",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_destroy_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createBuffer_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createTexture_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createSampler_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createBindGroupLayout_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createPipelineLayout_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createBindGroup_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createShaderModule_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createComputePipeline_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createRenderPipeline_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createComputePipelineAsync_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createRenderPipelineAsync_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createCommandEncoder_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_createRenderBundleEncoder_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_pushErrorScope_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUDevice_Binding::init_popErrorScope_methodinfo::<D>();
            init_features_getterinfo::<D>();
init_limits_getterinfo::<D>();
init_adapterInfo_getterinfo::<D>();
init_queue_getterinfo::<D>();
init_lost_getterinfo::<D>();
init_onuncapturederror_getterinfo::<D>();
init_label_getterinfo::<D>();
            init_onuncapturederror_setterinfo::<D>();
init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUDevice_Binding


pub use self::GPUDeviceLostInfo_Binding::{Wrap as GPUDeviceLostInfoWrap, GPUDeviceLostInfoMethods, GetProtoObject as GPUDeviceLostInfoGetProtoObject, DefineDOMInterface as GPUDeviceLostInfoDefineDOMInterface};
pub mod GPUDeviceLostInfo_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUDeviceLostReason;
use crate::codegen::GenericBindings::WebGPUBinding::GPUDeviceLostReasonValues;
use crate::import::module::*;

unsafe extern "C" fn get_reason<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDeviceLostInfo);
        let result: GPUDeviceLostReason = this.Reason();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static reason_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_reason_getterinfo<D: DomTypes>() {
    reason_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_reason::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDeviceLostInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_message<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUDeviceLostInfo);
        let result: DOMString = this.Message();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static message_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_message_getterinfo<D: DomTypes>() {
    message_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_message::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUDeviceLostInfo as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUDeviceLostInfo>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUDeviceLostInfo>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUDeviceLostInfo".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUDeviceLostInfo, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUDeviceLostInfo> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUDeviceLostInfo>, _can_gc: CanGc) -> DomRoot<D::GPUDeviceLostInfo>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUDeviceLostInfoMethods<D: DomTypes> {
    fn Reason(&self, ) -> GPUDeviceLostReason;
    fn Message(&self, ) -> DOMString;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"reason".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { reason_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"message".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { message_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUDeviceLostInfo".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUDeviceLostInfo), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUDeviceLostInfoPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUDeviceLostInfo() {\n    [native code]\n}",
        PrototypeList::ID::GPUDeviceLostInfo,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUDeviceLostInfo),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUDeviceLostInfo as usize].is_null());
    (*cache)[PrototypeList::ID::GPUDeviceLostInfo as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUDeviceLostInfo as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUDeviceLostInfo",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_reason_getterinfo::<D>();
init_message_getterinfo::<D>();


            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUDeviceLostInfo_Binding


pub use self::GPUError_Binding::{Wrap as GPUErrorWrap, GPUErrorMethods, GetProtoObject as GPUErrorGetProtoObject, GetConstructorObject as GPUErrorGetConstructorObject, DefineDOMInterface as GPUErrorDefineDOMInterface};
pub mod GPUError_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_message<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUError);
        let result: DOMString = this.Message();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static message_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_message_getterinfo<D: DomTypes>() {
    message_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_message::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUError as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUError>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUError>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUError".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUError, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { gpuerror: (crate::codegen::InheritTypes::GPUErrorTypeId::GPUError) },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUError> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUError>, _can_gc: CanGc) -> DomRoot<D::GPUError>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUErrorMethods<D: DomTypes> {
    fn Message(&self, ) -> DOMString;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"message".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { message_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUError".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUError), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUErrorPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUError() {\n    [native code]\n}",
        PrototypeList::ID::GPUError,
        0,
    ));
}

pub fn GetConstructorObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface object for this class.  This will create the object as
       needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::GPUError), CreateInterfaceObjects::<D>, rval)
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUError),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUError as usize].is_null());
    (*cache)[PrototypeList::ID::GPUError as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUError as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUError",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());

    assert!((*cache)[PrototypeList::Constructor::GPUError as usize].is_null());
    (*cache)[PrototypeList::Constructor::GPUError as usize] = interface.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::GPUError as isize),
                                  ptr::null_mut(),
                                  interface.get());

}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_message_getterinfo::<D>();


            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUError_Binding


pub use self::GPUInternalError_Binding::{Wrap as GPUInternalErrorWrap, GPUInternalErrorMethods, GetProtoObject as GPUInternalErrorGetProtoObject, DefineDOMInterface as GPUInternalErrorDefineDOMInterface};
pub mod GPUInternalError_Binding {
use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
use crate::codegen::GenericBindings::WebGPUBinding::GPUError_Binding;
use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
use crate::import::module::*;

unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUInternalError>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUInternalError>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUInternalError".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUError, PrototypeList::ID::GPUInternalError, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 1,
    type_id: crate::codegen::InheritTypes::TopTypeId { gpuerror: (crate::codegen::InheritTypes::GPUErrorTypeId::GPUInternalError) },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUInternalError> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUInternalError>, _can_gc: CanGc) -> DomRoot<D::GPUInternalError>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUInternalErrorMethods<D: DomTypes> {
    fn Constructor(r#global: &D::GlobalScope, r#proto: Option<HandleObject>, r#can_gc: CanGc, r#message: DOMString) -> DomRoot<D::GPUInternalError>;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUInternalError".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[0])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUInternalError), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUInternalErrorPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

unsafe extern "C" fn _constructor<D: DomTypes>
(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let args = CallArgs::from_vp(vp, argc);
        let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());

                    call_default_constructor::<D>(
                        SafeJSContext::from_ptr(cx.raw_cx()),
                        &args,
                        &global,
                        PrototypeList::ID::GPUInternalError,
                        "GPUInternalError",
                        CreateInterfaceObjects::<D>,
                        |cx: SafeJSContext, args: &CallArgs, global: &D::GlobalScope, desired_proto: HandleObject| {

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUInternalError.constructor\".");
            return false;
        }
        let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: DomRoot<D::GPUInternalError> = <D::GPUInternalError>::Constructor(global, Some(desired_proto), CanGc::note(), arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
                        }
                    )

    });
    result
}


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
        b"function GPUInternalError() {\n    [native code]\n}",
        PrototypeList::ID::GPUInternalError,
        1,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUInternalError),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    GPUError_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUInternalError as usize].is_null());
    (*cache)[PrototypeList::ID::GPUInternalError as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUInternalError as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());

    GPUError_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUInternalError",
                                        1,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();




            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUInternalError_Binding


pub use self::GPUMapMode_Binding::{GPUMapModeConstants, GetConstructorObject as GPUMapModeGetConstructorObject, DefineDOMInterface as GPUMapModeDefineDOMInterface};
pub mod GPUMapMode_Binding {
use crate::import::module::*;

pub mod GPUMapModeConstants {
    pub const READ: u32 = 1;
    pub const WRITE: u32 = 2;
} // mod GPUMapModeConstants
pub trait GPUMapModeMethods<D: DomTypes> {
}
static sConstants_specs: ThreadUnsafeOnceLock<&[&[ConstantSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_specs<D: DomTypes>() {
    sConstants_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    ConstantSpec { name: c"READ", value: ConstantVal::Uint(1) },
    ConstantSpec { name: c"WRITE", value: ConstantVal::Uint(2) }]))[..]
])));
}static sConstants: ThreadUnsafeOnceLock<&[Guard<&[ConstantSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_prefs<D: DomTypes>() {
    sConstants.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[0])])));
}

static NAMESPACE_OBJECT_CLASS: NamespaceObjectClass = unsafe {
    NamespaceObjectClass::new(c"Object")
};

pub fn GetConstructorObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface object for this class.  This will create the object as
       needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::GPUMapMode), CreateInterfaceObjects::<D>, rval)
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::Constructor(PrototypeList::Constructor::GPUMapMode),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let proto = JS_NewPlainObject(cx.raw_cx()));
    assert!(!proto.is_null());
    rooted!(&in(cx) let mut namespace = ptr::null_mut::<JSObject>());
    create_namespace_object::<D>(cx, global, proto.handle(), &NAMESPACE_OBJECT_CLASS,
                            &[], sConstants.get(), c"GPUMapMode", namespace.handle_mut());
    assert!(!namespace.is_null());
    assert!((*cache)[PrototypeList::Constructor::GPUMapMode as usize].is_null());
    (*cache)[PrototypeList::Constructor::GPUMapMode as usize] = namespace.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::Constructor::GPUMapMode as isize),
                                  ptr::null_mut(),
                                  namespace.get());

}


        pub(crate) fn init_statics<D: DomTypes>() {






            init_sConstants_specs::<D>();
init_sConstants_prefs::<D>();
        }
        } // mod GPUMapMode_Binding


pub use self::GPUOutOfMemoryError_Binding::{Wrap as GPUOutOfMemoryErrorWrap, GPUOutOfMemoryErrorMethods, GetProtoObject as GPUOutOfMemoryErrorGetProtoObject, DefineDOMInterface as GPUOutOfMemoryErrorDefineDOMInterface};
pub mod GPUOutOfMemoryError_Binding {
use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
use crate::codegen::GenericBindings::WebGPUBinding::GPUError_Binding;
use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
use crate::import::module::*;

unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUOutOfMemoryError>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUOutOfMemoryError>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUOutOfMemoryError".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUError, PrototypeList::ID::GPUOutOfMemoryError, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 1,
    type_id: crate::codegen::InheritTypes::TopTypeId { gpuerror: (crate::codegen::InheritTypes::GPUErrorTypeId::GPUOutOfMemoryError) },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUOutOfMemoryError> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUOutOfMemoryError>, _can_gc: CanGc) -> DomRoot<D::GPUOutOfMemoryError>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUOutOfMemoryErrorMethods<D: DomTypes> {
    fn Constructor(r#global: &D::GlobalScope, r#proto: Option<HandleObject>, r#can_gc: CanGc, r#message: DOMString) -> DomRoot<D::GPUOutOfMemoryError>;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUOutOfMemoryError".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[0])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUOutOfMemoryError), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUOutOfMemoryErrorPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

unsafe extern "C" fn _constructor<D: DomTypes>
(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let args = CallArgs::from_vp(vp, argc);
        let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());

                    call_default_constructor::<D>(
                        SafeJSContext::from_ptr(cx.raw_cx()),
                        &args,
                        &global,
                        PrototypeList::ID::GPUOutOfMemoryError,
                        "GPUOutOfMemoryError",
                        CreateInterfaceObjects::<D>,
                        |cx: SafeJSContext, args: &CallArgs, global: &D::GlobalScope, desired_proto: HandleObject| {

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUOutOfMemoryError.constructor\".");
            return false;
        }
        let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: DomRoot<D::GPUOutOfMemoryError> = <D::GPUOutOfMemoryError>::Constructor(global, Some(desired_proto), CanGc::note(), arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
                        }
                    )

    });
    result
}


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
        b"function GPUOutOfMemoryError() {\n    [native code]\n}",
        PrototypeList::ID::GPUOutOfMemoryError,
        1,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUOutOfMemoryError),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    GPUError_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUOutOfMemoryError as usize].is_null());
    (*cache)[PrototypeList::ID::GPUOutOfMemoryError as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUOutOfMemoryError as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());

    GPUError_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUOutOfMemoryError",
                                        1,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();




            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUOutOfMemoryError_Binding


pub use self::GPUPipelineError_Binding::{Wrap as GPUPipelineErrorWrap, GPUPipelineErrorMethods, GetProtoObject as GPUPipelineErrorGetProtoObject, DefineDOMInterface as GPUPipelineErrorDefineDOMInterface};
pub mod GPUPipelineError_Binding {
use crate::codegen::GenericBindings::DOMExceptionBinding::DOMException_Binding;
use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
use crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineErrorInit;
use crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineErrorReason;
use crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineErrorReasonValues;
use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
use crate::import::module::*;

unsafe extern "C" fn get_reason<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUPipelineError);
        let result: GPUPipelineErrorReason = this.Reason();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static reason_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_reason_getterinfo<D: DomTypes>() {
    reason_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_reason::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUPipelineError as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUPipelineError>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUPipelineError>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUPipelineError".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::DOMException, PrototypeList::ID::GPUPipelineError, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 1,
    type_id: crate::codegen::InheritTypes::TopTypeId { domexception: (crate::codegen::InheritTypes::DOMExceptionTypeId::GPUPipelineError) },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUPipelineError> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUPipelineError>, _can_gc: CanGc) -> DomRoot<D::GPUPipelineError>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUPipelineErrorMethods<D: DomTypes> {
    fn Reason(&self, ) -> GPUPipelineErrorReason;
    fn Constructor(r#global: &D::GlobalScope, r#proto: Option<HandleObject>, r#can_gc: CanGc, r#message: DOMString, r#options: &crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineErrorInit) -> DomRoot<D::GPUPipelineError>;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"reason".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { reason_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUPipelineError".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUPipelineError), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUPipelineErrorPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

unsafe extern "C" fn _constructor<D: DomTypes>
(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let args = CallArgs::from_vp(vp, argc);
        let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());

                    call_default_constructor::<D>(
                        SafeJSContext::from_ptr(cx.raw_cx()),
                        &args,
                        &global,
                        PrototypeList::ID::GPUPipelineError,
                        "GPUPipelineError",
                        CreateInterfaceObjects::<D>,
                        |cx: SafeJSContext, args: &CallArgs, global: &D::GlobalScope, desired_proto: HandleObject| {

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUPipelineError.constructor\".");
            return false;
        }
        let arg0: DOMString = if args.get(0).is_undefined() {
            DOMString::from("")
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg1: crate::codegen::GenericBindings::WebGPUBinding::GPUPipelineErrorInit = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: DomRoot<D::GPUPipelineError> = <D::GPUPipelineError>::Constructor(global, Some(desired_proto), CanGc::note(), arg0, &arg1);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
                        }
                    )

    });
    result
}


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
        b"function GPUPipelineError() {\n    [native code]\n}",
        PrototypeList::ID::GPUPipelineError,
        1,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUPipelineError),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    DOMException_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUPipelineError as usize].is_null());
    (*cache)[PrototypeList::ID::GPUPipelineError as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUPipelineError as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());

    DOMException_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUPipelineError",
                                        1,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_reason_getterinfo::<D>();


            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUPipelineError_Binding


pub use self::GPUPipelineLayout_Binding::{Wrap as GPUPipelineLayoutWrap, GPUPipelineLayoutMethods, GetProtoObject as GPUPipelineLayoutGetProtoObject, DefineDOMInterface as GPUPipelineLayoutDefineDOMInterface};
pub mod GPUPipelineLayout_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUPipelineLayout);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUPipelineLayout);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUPipelineLayout as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUPipelineLayout as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUPipelineLayout>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUPipelineLayout>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUPipelineLayout".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUPipelineLayout, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUPipelineLayout> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUPipelineLayout>, _can_gc: CanGc) -> DomRoot<D::GPUPipelineLayout>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUPipelineLayoutMethods<D: DomTypes> {
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUPipelineLayout".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUPipelineLayout), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUPipelineLayoutPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUPipelineLayout() {\n    [native code]\n}",
        PrototypeList::ID::GPUPipelineLayout,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUPipelineLayout),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUPipelineLayout as usize].is_null());
    (*cache)[PrototypeList::ID::GPUPipelineLayout as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUPipelineLayout as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUPipelineLayout",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUPipelineLayout_Binding


pub use self::GPUQuerySet_Binding::{Wrap as GPUQuerySetWrap, GPUQuerySetMethods, GetProtoObject as GPUQuerySetGetProtoObject, DefineDOMInterface as GPUQuerySetDefineDOMInterface};
pub mod GPUQuerySet_Binding {
use crate::import::module::*;

unsafe extern "C" fn destroy<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUQuerySet);
        let args = &*args;
        let argc = args.argc_;
        let result: () = this.Destroy();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static destroy_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_destroy_methodinfo<D: DomTypes>() {
    destroy_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(destroy::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUQuerySet as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUQuerySet);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUQuerySet);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUQuerySet as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUQuerySet as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUQuerySet>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUQuerySet>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUQuerySet".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUQuerySet, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUQuerySet> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUQuerySet>, _can_gc: CanGc) -> DomRoot<D::GPUQuerySet>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUQuerySetMethods<D: DomTypes> {
    fn Destroy(&self, );
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"destroy".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { destroy_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUQuerySet".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUQuerySet), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUQuerySetPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUQuerySet() {\n    [native code]\n}",
        PrototypeList::ID::GPUQuerySet,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUQuerySet),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUQuerySet as usize].is_null());
    (*cache)[PrototypeList::ID::GPUQuerySet as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUQuerySet as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUQuerySet",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUQuerySet_Binding::init_destroy_methodinfo::<D>();
            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUQuerySet_Binding


pub use self::GPUQueue_Binding::{Wrap as GPUQueueWrap, GPUQueueMethods, GetProtoObject as GPUQueueGetProtoObject, DefineDOMInterface as GPUQueueDefineDOMInterface};
pub mod GPUQueue_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUExtent3DDict;
use crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture;
use crate::codegen::GenericBindings::WebGPUBinding::GPUImageDataLayout;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureAspect;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureAspectValues;
use crate::import::module::*;

unsafe extern "C" fn submit<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUQueue);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUQueue.submit\".");
            return false;
        }
        let arg0: Vec<DomRoot<D::GPUCommandBuffer>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.Submit(arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static submit_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_submit_methodinfo<D: DomTypes>() {
    submit_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(submit::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUQueue as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn onSubmittedWorkDone<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUQueue);
        let args = &*args;
        let argc = args.argc_;
        let result: Rc<D::Promise> = this.OnSubmittedWorkDone(CanGc::note());

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn onSubmittedWorkDone_promise_wrapper<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let ok = onSubmittedWorkDone::<D>(cx, _obj, this, args);
        if ok {
          return true;
        }
        return exception_to_promise(cx, (*args).rval(), CanGc::note());

    })());
    result
}


static onSubmittedWorkDone_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_onSubmittedWorkDone_methodinfo<D: DomTypes>() {
    onSubmittedWorkDone_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(onSubmittedWorkDone_promise_wrapper::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUQueue as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn writeBuffer<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUQueue);
        let args = &*args;
        let argc = args.argc_;

        if argc < 3 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUQueue.writeBuffer\".");
            return false;
        }
        let arg0: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: GenericUnionTypes::ArrayBufferViewOrArrayBuffer = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg3: u64 = if args.get(3).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg4: Option<u64> = if args.get(4).is_undefined() {
            None
        } else {
            Some(match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }
            )
        };
        let result: Result<(), Error> = this.WriteBuffer(&arg0, arg1, arg2, arg3, arg4);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static writeBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_writeBuffer_methodinfo<D: DomTypes>() {
    writeBuffer_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(writeBuffer::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUQueue as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn writeTexture<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUQueue);
        let args = &*args;
        let argc = args.argc_;

        if argc < 4 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUQueue.writeTexture\".");
            return false;
        }
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: GenericUnionTypes::ArrayBufferViewOrArrayBuffer = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: crate::codegen::GenericBindings::WebGPUBinding::GPUImageDataLayout = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg3: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<(), Error> = this.WriteTexture(&arg0, arg1, &arg2, arg3);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static writeTexture_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_writeTexture_methodinfo<D: DomTypes>() {
    writeTexture_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(writeTexture::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUQueue as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUQueue);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUQueue);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUQueue as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUQueue as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUQueue>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUQueue>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUQueue".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUQueue, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUQueue> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUQueue>, _can_gc: CanGc) -> DomRoot<D::GPUQueue>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUQueueMethods<D: DomTypes> {
    fn Submit(&self, r#buffers: Vec<DomRoot<D::GPUCommandBuffer>>);
    fn OnSubmittedWorkDone(&self, r#_can_gc: CanGc) -> Rc<D::Promise>;
    fn WriteBuffer(&self, r#buffer: &D::GPUBuffer, r#bufferOffset: u64, r#data: GenericUnionTypes::ArrayBufferViewOrArrayBuffer, r#dataOffset: u64, r#size: Option<u64>) -> Fallible<()>;
    fn WriteTexture(&self, r#destination: &crate::codegen::GenericBindings::WebGPUBinding::GPUImageCopyTexture<D>, r#data: GenericUnionTypes::ArrayBufferViewOrArrayBuffer, r#dataLayout: &crate::codegen::GenericBindings::WebGPUBinding::GPUImageDataLayout, r#size: GenericUnionTypes::RangeEnforcedUnsignedLongSequenceOrGPUExtent3DDict) -> Fallible<()>;
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"submit".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { submit_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"onSubmittedWorkDone".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { onSubmittedWorkDone_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"writeBuffer".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { writeBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 3,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"writeTexture".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { writeTexture_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 4,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUQueue".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUQueue), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUQueuePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUQueue() {\n    [native code]\n}",
        PrototypeList::ID::GPUQueue,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUQueue),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUQueue as usize].is_null());
    (*cache)[PrototypeList::ID::GPUQueue as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUQueue as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUQueue",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUQueue_Binding::init_submit_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUQueue_Binding::init_onSubmittedWorkDone_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUQueue_Binding::init_writeBuffer_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUQueue_Binding::init_writeTexture_methodinfo::<D>();
            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUQueue_Binding


pub use self::GPURenderBundle_Binding::{Wrap as GPURenderBundleWrap, GPURenderBundleMethods, GetProtoObject as GPURenderBundleGetProtoObject, DefineDOMInterface as GPURenderBundleDefineDOMInterface};
pub mod GPURenderBundle_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundle);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundle);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundle as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundle as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPURenderBundle>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPURenderBundle>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPURenderBundle".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPURenderBundle, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPURenderBundle> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPURenderBundle>, _can_gc: CanGc) -> DomRoot<D::GPURenderBundle>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPURenderBundleMethods<D: DomTypes> {
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPURenderBundle".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPURenderBundle), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPURenderBundlePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPURenderBundle() {\n    [native code]\n}",
        PrototypeList::ID::GPURenderBundle,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPURenderBundle),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPURenderBundle as usize].is_null());
    (*cache)[PrototypeList::ID::GPURenderBundle as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPURenderBundle as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPURenderBundle",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPURenderBundle_Binding


pub use self::GPURenderBundleEncoder_Binding::{Wrap as GPURenderBundleEncoderWrap, GPURenderBundleEncoderMethods, GetProtoObject as GPURenderBundleEncoderGetProtoObject, DefineDOMInterface as GPURenderBundleEncoderDefineDOMInterface};
pub mod GPURenderBundleEncoder_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUIndexFormat;
use crate::codegen::GenericBindings::WebGPUBinding::GPUIndexFormatValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleDescriptor;
use crate::import::module::*;

unsafe extern "C" fn finish<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let args = &*args;
        let argc = args.argc_;
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleDescriptor = if args.get(0).is_undefined() {
            crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleDescriptor::empty()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: DomRoot<D::GPURenderBundle> = this.Finish(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static finish_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_finish_methodinfo<D: DomTypes>() {
    finish_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(finish::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setBindGroup<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderBundleEncoder.setBindGroup\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: DomRoot<D::GPUBindGroup> = if HandleValue::from_raw(args.get(1)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBindGroup.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg2: Vec<u32> = if args.get(2).is_undefined() {
            Vec::new()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.SetBindGroup(arg0, &arg1, arg2);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setBindGroup_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setBindGroup_methodinfo<D: DomTypes>() {
    setBindGroup_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setBindGroup::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setPipeline<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderBundleEncoder.setPipeline\".");
            return false;
        }
        let arg0: DomRoot<D::GPURenderPipeline> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPURenderPipeline.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let result: () = this.SetPipeline(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setPipeline_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setPipeline_methodinfo<D: DomTypes>() {
    setPipeline_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setPipeline::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setIndexBuffer<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderBundleEncoder.setIndexBuffer\".");
            return false;
        }
        let arg0: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: GPUIndexFormat = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error); return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: u64 = if args.get(2).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg3: u64 = if args.get(3).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.SetIndexBuffer(&arg0, arg1, arg2, arg3);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setIndexBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setIndexBuffer_methodinfo<D: DomTypes>() {
    setIndexBuffer_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setIndexBuffer::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setVertexBuffer<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderBundleEncoder.setVertexBuffer\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(1)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg2: u64 = if args.get(2).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg3: u64 = if args.get(3).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.SetVertexBuffer(arg0, &arg1, arg2, arg3);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setVertexBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setVertexBuffer_methodinfo<D: DomTypes>() {
    setVertexBuffer_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setVertexBuffer::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn draw<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderBundleEncoder.draw\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: u32 = if args.get(1).is_undefined() {
            1
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg2: u32 = if args.get(2).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg3: u32 = if args.get(3).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.Draw(arg0, arg1, arg2, arg3);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static draw_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_draw_methodinfo<D: DomTypes>() {
    draw_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(draw::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn drawIndexed<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderBundleEncoder.drawIndexed\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: u32 = if args.get(1).is_undefined() {
            1
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg2: u32 = if args.get(2).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg3: i32 = if args.get(3).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg4: u32 = if args.get(4).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.DrawIndexed(arg0, arg1, arg2, arg3, arg4);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static drawIndexed_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_drawIndexed_methodinfo<D: DomTypes>() {
    drawIndexed_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(drawIndexed::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn drawIndirect<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderBundleEncoder.drawIndirect\".");
            return false;
        }
        let arg0: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.DrawIndirect(&arg0, arg1);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static drawIndirect_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_drawIndirect_methodinfo<D: DomTypes>() {
    drawIndirect_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(drawIndirect::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn drawIndexedIndirect<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderBundleEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderBundleEncoder.drawIndexedIndirect\".");
            return false;
        }
        let arg0: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.DrawIndexedIndirect(&arg0, arg1);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static drawIndexedIndirect_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_drawIndexedIndirect_methodinfo<D: DomTypes>() {
    drawIndexedIndirect_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(drawIndexedIndirect::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderBundleEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPURenderBundleEncoder>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPURenderBundleEncoder>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPURenderBundleEncoder".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPURenderBundleEncoder, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPURenderBundleEncoder> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPURenderBundleEncoder>, _can_gc: CanGc) -> DomRoot<D::GPURenderBundleEncoder>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPURenderBundleEncoderMethods<D: DomTypes> {
    fn Finish(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleDescriptor) -> DomRoot<D::GPURenderBundle>;
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
    fn SetBindGroup(&self, r#index: u32, r#bindGroup: &D::GPUBindGroup, r#dynamicOffsets: Vec<u32>);
    fn SetPipeline(&self, r#pipeline: &D::GPURenderPipeline);
    fn SetIndexBuffer(&self, r#buffer: &D::GPUBuffer, r#indexFormat: GPUIndexFormat, r#offset: u64, r#size: u64);
    fn SetVertexBuffer(&self, r#slot: u32, r#buffer: &D::GPUBuffer, r#offset: u64, r#size: u64);
    fn Draw(&self, r#vertexCount: u32, r#instanceCount: u32, r#firstVertex: u32, r#firstInstance: u32);
    fn DrawIndexed(&self, r#indexCount: u32, r#instanceCount: u32, r#firstIndex: u32, r#baseVertex: i32, r#firstInstance: u32);
    fn DrawIndirect(&self, r#indirectBuffer: &D::GPUBuffer, r#indirectOffset: u64);
    fn DrawIndexedIndirect(&self, r#indirectBuffer: &D::GPUBuffer, r#indirectOffset: u64);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"finish".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { finish_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setBindGroup".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setBindGroup_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setPipeline".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setPipeline_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setIndexBuffer".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setIndexBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setVertexBuffer".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setVertexBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"draw".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { draw_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"drawIndexed".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawIndexed_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"drawIndirect".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawIndirect_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"drawIndexedIndirect".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawIndexedIndirect_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPURenderBundleEncoder".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPURenderBundleEncoder), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPURenderBundleEncoderPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPURenderBundleEncoder() {\n    [native code]\n}",
        PrototypeList::ID::GPURenderBundleEncoder,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPURenderBundleEncoder),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPURenderBundleEncoder as usize].is_null());
    (*cache)[PrototypeList::ID::GPURenderBundleEncoder as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPURenderBundleEncoder as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPURenderBundleEncoder",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoder_Binding::init_finish_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoder_Binding::init_setBindGroup_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoder_Binding::init_setPipeline_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoder_Binding::init_setIndexBuffer_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoder_Binding::init_setVertexBuffer_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoder_Binding::init_draw_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoder_Binding::init_drawIndexed_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoder_Binding::init_drawIndirect_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderBundleEncoder_Binding::init_drawIndexedIndirect_methodinfo::<D>();
            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPURenderBundleEncoder_Binding


pub use self::GPURenderPassEncoder_Binding::{Wrap as GPURenderPassEncoderWrap, GPURenderPassEncoderMethods, GetProtoObject as GPURenderPassEncoderGetProtoObject, DefineDOMInterface as GPURenderPassEncoderDefineDOMInterface};
pub mod GPURenderPassEncoder_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUColorDict;
use crate::codegen::GenericBindings::WebGPUBinding::GPUIndexFormat;
use crate::codegen::GenericBindings::WebGPUBinding::GPUIndexFormatValues;
use crate::import::module::*;

unsafe extern "C" fn setViewport<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 6 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.setViewport\".");
            return false;
        }
        let arg0: Finite<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: Finite<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: Finite<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg3: Finite<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg4: Finite<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg5: Finite<f32> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(5)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetViewport(arg0, arg1, arg2, arg3, arg4, arg5);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setViewport_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setViewport_methodinfo<D: DomTypes>() {
    setViewport_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setViewport::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setScissorRect<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 4 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.setScissorRect\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg3: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetScissorRect(arg0, arg1, arg2, arg3);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setScissorRect_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setScissorRect_methodinfo<D: DomTypes>() {
    setScissorRect_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setScissorRect::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setBlendConstant<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.setBlendConstant\".");
            return false;
        }
        let arg0: GenericUnionTypes::DoubleSequenceOrGPUColorDict = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<(), Error> = this.SetBlendConstant(arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setBlendConstant_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setBlendConstant_methodinfo<D: DomTypes>() {
    setBlendConstant_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setBlendConstant::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setStencilReference<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.setStencilReference\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetStencilReference(arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setStencilReference_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setStencilReference_methodinfo<D: DomTypes>() {
    setStencilReference_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setStencilReference::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn executeBundles<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.executeBundles\".");
            return false;
        }
        let arg0: Vec<DomRoot<D::GPURenderBundle>> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.ExecuteBundles(arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static executeBundles_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_executeBundles_methodinfo<D: DomTypes>() {
    executeBundles_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(executeBundles::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn end<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;
        let result: () = this.End();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static end_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_end_methodinfo<D: DomTypes>() {
    end_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(end::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setBindGroup<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.setBindGroup\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: DomRoot<D::GPUBindGroup> = if HandleValue::from_raw(args.get(1)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBindGroup.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg2: Vec<u32> = if args.get(2).is_undefined() {
            Vec::new()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.SetBindGroup(arg0, &arg1, arg2);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setBindGroup_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setBindGroup_methodinfo<D: DomTypes>() {
    setBindGroup_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setBindGroup::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setPipeline<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.setPipeline\".");
            return false;
        }
        let arg0: DomRoot<D::GPURenderPipeline> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPURenderPipeline.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let result: () = this.SetPipeline(&arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setPipeline_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setPipeline_methodinfo<D: DomTypes>() {
    setPipeline_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setPipeline::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setIndexBuffer<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.setIndexBuffer\".");
            return false;
        }
        let arg0: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: GPUIndexFormat = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error); return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg2: u64 = if args.get(2).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg3: u64 = if args.get(3).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.SetIndexBuffer(&arg0, arg1, arg2, arg3);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setIndexBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setIndexBuffer_methodinfo<D: DomTypes>() {
    setIndexBuffer_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setIndexBuffer::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn setVertexBuffer<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.setVertexBuffer\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(1)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(1)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg2: u64 = if args.get(2).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg3: u64 = if args.get(3).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.SetVertexBuffer(arg0, &arg1, arg2, arg3);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static setVertexBuffer_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_setVertexBuffer_methodinfo<D: DomTypes>() {
    setVertexBuffer_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(setVertexBuffer::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn draw<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.draw\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: u32 = if args.get(1).is_undefined() {
            1
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg2: u32 = if args.get(2).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg3: u32 = if args.get(3).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.Draw(arg0, arg1, arg2, arg3);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static draw_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_draw_methodinfo<D: DomTypes>() {
    draw_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(draw::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn drawIndexed<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.drawIndexed\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: u32 = if args.get(1).is_undefined() {
            1
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg2: u32 = if args.get(2).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(2)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg3: i32 = if args.get(3).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(3)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let arg4: u32 = if args.get(4).is_undefined() {
            0
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(4)), ConversionBehavior::EnforceRange) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: () = this.DrawIndexed(arg0, arg1, arg2, arg3, arg4);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static drawIndexed_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_drawIndexed_methodinfo<D: DomTypes>() {
    drawIndexed_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(drawIndexed::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn drawIndirect<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.drawIndirect\".");
            return false;
        }
        let arg0: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.DrawIndirect(&arg0, arg1);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static drawIndirect_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_drawIndirect_methodinfo<D: DomTypes>() {
    drawIndirect_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(drawIndirect::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn drawIndexedIndirect<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPassEncoder);
        let args = &*args;
        let argc = args.argc_;

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPassEncoder.drawIndexedIndirect\".");
            return false;
        }
        let arg0: DomRoot<D::GPUBuffer> = if HandleValue::from_raw(args.get(0)).get().is_object() {
            match root_from_handlevalue(HandleValue::from_raw(args.get(0)), SafeJSContext::from_ptr(cx.raw_cx())) {
                Ok(val) => val,
                Err(()) => {
                    throw_type_error(cx.raw_cx(), "value does not implement interface GPUBuffer.");
                    return false;

                }
            }

        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: u64 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ConversionBehavior::EnforceRange) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.DrawIndexedIndirect(&arg0, arg1);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static drawIndexedIndirect_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_drawIndexedIndirect_methodinfo<D: DomTypes>() {
    drawIndexedIndirect_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(drawIndexedIndirect::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPassEncoder as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPURenderPassEncoder>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPURenderPassEncoder>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPURenderPassEncoder".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPURenderPassEncoder, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPURenderPassEncoder> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPURenderPassEncoder>, _can_gc: CanGc) -> DomRoot<D::GPURenderPassEncoder>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPURenderPassEncoderMethods<D: DomTypes> {
    fn SetViewport(&self, r#x: Finite<f32>, r#y: Finite<f32>, r#width: Finite<f32>, r#height: Finite<f32>, r#minDepth: Finite<f32>, r#maxDepth: Finite<f32>);
    fn SetScissorRect(&self, r#x: u32, r#y: u32, r#width: u32, r#height: u32);
    fn SetBlendConstant(&self, r#color: GenericUnionTypes::DoubleSequenceOrGPUColorDict) -> Fallible<()>;
    fn SetStencilReference(&self, r#reference: u32);
    fn ExecuteBundles(&self, r#bundles: Vec<DomRoot<D::GPURenderBundle>>);
    fn End(&self, );
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
    fn SetBindGroup(&self, r#index: u32, r#bindGroup: &D::GPUBindGroup, r#dynamicOffsets: Vec<u32>);
    fn SetPipeline(&self, r#pipeline: &D::GPURenderPipeline);
    fn SetIndexBuffer(&self, r#buffer: &D::GPUBuffer, r#indexFormat: GPUIndexFormat, r#offset: u64, r#size: u64);
    fn SetVertexBuffer(&self, r#slot: u32, r#buffer: &D::GPUBuffer, r#offset: u64, r#size: u64);
    fn Draw(&self, r#vertexCount: u32, r#instanceCount: u32, r#firstVertex: u32, r#firstInstance: u32);
    fn DrawIndexed(&self, r#indexCount: u32, r#instanceCount: u32, r#firstIndex: u32, r#baseVertex: i32, r#firstInstance: u32);
    fn DrawIndirect(&self, r#indirectBuffer: &D::GPUBuffer, r#indirectOffset: u64);
    fn DrawIndexedIndirect(&self, r#indirectBuffer: &D::GPUBuffer, r#indirectOffset: u64);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setViewport".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setViewport_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 6,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setScissorRect".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setScissorRect_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 4,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setBlendConstant".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setBlendConstant_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setStencilReference".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setStencilReference_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"executeBundles".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { executeBundles_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"end".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { end_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setBindGroup".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setBindGroup_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setPipeline".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setPipeline_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setIndexBuffer".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setIndexBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"setVertexBuffer".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { setVertexBuffer_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"draw".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { draw_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"drawIndexed".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawIndexed_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"drawIndirect".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawIndirect_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"drawIndexedIndirect".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { drawIndexedIndirect_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 2,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPURenderPassEncoder".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPURenderPassEncoder), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPURenderPassEncoderPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPURenderPassEncoder() {\n    [native code]\n}",
        PrototypeList::ID::GPURenderPassEncoder,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPURenderPassEncoder),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPURenderPassEncoder as usize].is_null());
    (*cache)[PrototypeList::ID::GPURenderPassEncoder as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPURenderPassEncoder as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPURenderPassEncoder",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_setViewport_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_setScissorRect_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_setBlendConstant_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_setStencilReference_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_executeBundles_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_end_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_setBindGroup_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_setPipeline_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_setIndexBuffer_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_setVertexBuffer_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_draw_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_drawIndexed_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_drawIndirect_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPURenderPassEncoder_Binding::init_drawIndexedIndirect_methodinfo::<D>();
            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPURenderPassEncoder_Binding


pub use self::GPURenderPipeline_Binding::{Wrap as GPURenderPipelineWrap, GPURenderPipelineMethods, GetProtoObject as GPURenderPipelineGetProtoObject, DefineDOMInterface as GPURenderPipelineDefineDOMInterface};
pub mod GPURenderPipeline_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPipeline);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPipeline);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPipeline as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPipeline as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn getBindGroupLayout<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPURenderPipeline);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPURenderPipeline.getBindGroupLayout\".");
            return false;
        }
        let arg0: u32 = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ConversionBehavior::Default) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: Result<DomRoot<D::GPUBindGroupLayout>, Error> = this.GetBindGroupLayout(arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static getBindGroupLayout_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_getBindGroupLayout_methodinfo<D: DomTypes>() {
    getBindGroupLayout_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(getBindGroupLayout::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPURenderPipeline as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPURenderPipeline>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPURenderPipeline>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPURenderPipeline".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPURenderPipeline, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPURenderPipeline> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPURenderPipeline>, _can_gc: CanGc) -> DomRoot<D::GPURenderPipeline>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPURenderPipelineMethods<D: DomTypes> {
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
    fn GetBindGroupLayout(&self, r#index: u32) -> Fallible<DomRoot<D::GPUBindGroupLayout>>;
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"getBindGroupLayout".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { getBindGroupLayout_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPURenderPipeline".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPURenderPipeline), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPURenderPipelinePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPURenderPipeline() {\n    [native code]\n}",
        PrototypeList::ID::GPURenderPipeline,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPURenderPipeline),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPURenderPipeline as usize].is_null());
    (*cache)[PrototypeList::ID::GPURenderPipeline as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPURenderPipeline as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPURenderPipeline",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPURenderPipeline_Binding::init_getBindGroupLayout_methodinfo::<D>();
            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPURenderPipeline_Binding


pub use self::GPUSampler_Binding::{Wrap as GPUSamplerWrap, GPUSamplerMethods, GetProtoObject as GPUSamplerGetProtoObject, DefineDOMInterface as GPUSamplerDefineDOMInterface};
pub mod GPUSampler_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSampler);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSampler);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSampler as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSampler as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUSampler>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUSampler>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUSampler".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUSampler, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUSampler> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUSampler>, _can_gc: CanGc) -> DomRoot<D::GPUSampler>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUSamplerMethods<D: DomTypes> {
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUSampler".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUSampler), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUSamplerPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUSampler() {\n    [native code]\n}",
        PrototypeList::ID::GPUSampler,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUSampler),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUSampler as usize].is_null());
    (*cache)[PrototypeList::ID::GPUSampler as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUSampler as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUSampler",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUSampler_Binding


pub use self::GPUShaderModule_Binding::{Wrap as GPUShaderModuleWrap, GPUShaderModuleMethods, GetProtoObject as GPUShaderModuleGetProtoObject, DefineDOMInterface as GPUShaderModuleDefineDOMInterface};
pub mod GPUShaderModule_Binding {
use crate::import::module::*;

unsafe extern "C" fn getCompilationInfo<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUShaderModule);
        let args = &*args;
        let argc = args.argc_;
        let result: Rc<D::Promise> = this.GetCompilationInfo();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn getCompilationInfo_promise_wrapper<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let ok = getCompilationInfo::<D>(cx, _obj, this, args);
        if ok {
          return true;
        }
        return exception_to_promise(cx, (*args).rval(), CanGc::note());

    })());
    result
}


static getCompilationInfo_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_getCompilationInfo_methodinfo<D: DomTypes>() {
    getCompilationInfo_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(getCompilationInfo_promise_wrapper::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUShaderModule as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUShaderModule);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUShaderModule);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUShaderModule as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUShaderModule as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUShaderModule>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUShaderModule>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUShaderModule".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUShaderModule, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUShaderModule> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUShaderModule>, _can_gc: CanGc) -> DomRoot<D::GPUShaderModule>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUShaderModuleMethods<D: DomTypes> {
    fn GetCompilationInfo(&self, ) -> Rc<D::Promise>;
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"getCompilationInfo".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<true>), info: unsafe { getCompilationInfo_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUShaderModule".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUShaderModule), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUShaderModulePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUShaderModule() {\n    [native code]\n}",
        PrototypeList::ID::GPUShaderModule,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUShaderModule),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUShaderModule as usize].is_null());
    (*cache)[PrototypeList::ID::GPUShaderModule as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUShaderModule as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUShaderModule",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUShaderModule_Binding::init_getCompilationInfo_methodinfo::<D>();
            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUShaderModule_Binding


pub use self::GPUShaderStage_Binding::{GPUShaderStageConstants, Wrap as GPUShaderStageWrap, GetProtoObject as GPUShaderStageGetProtoObject, DefineDOMInterface as GPUShaderStageDefineDOMInterface};
pub mod GPUShaderStage_Binding {
use crate::import::module::*;

unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUShaderStage>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUShaderStage>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}

pub mod GPUShaderStageConstants {
    pub const VERTEX: u32 = 1;
    pub const FRAGMENT: u32 = 2;
    pub const COMPUTE: u32 = 4;
} // mod GPUShaderStageConstants

static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUShaderStage".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUShaderStage, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUShaderStage> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUShaderStage>, _can_gc: CanGc) -> DomRoot<D::GPUShaderStage>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUShaderStageMethods<D: DomTypes> {
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUShaderStage".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[0])])));
}static sConstants_specs: ThreadUnsafeOnceLock<&[&[ConstantSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_specs<D: DomTypes>() {
    sConstants_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    ConstantSpec { name: c"VERTEX", value: ConstantVal::Uint(1) },
    ConstantSpec { name: c"FRAGMENT", value: ConstantVal::Uint(2) },
    ConstantSpec { name: c"COMPUTE", value: ConstantVal::Uint(4) }]))[..]
])));
}static sConstants: ThreadUnsafeOnceLock<&[Guard<&[ConstantSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_prefs<D: DomTypes>() {
    sConstants.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[0])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUShaderStage), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUShaderStagePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUShaderStage() {\n    [native code]\n}",
        PrototypeList::ID::GPUShaderStage,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUShaderStage),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      sConstants.get(),
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUShaderStage as usize].is_null());
    (*cache)[PrototypeList::ID::GPUShaderStage as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUShaderStage as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        sConstants.get(),
                                        prototype.handle(),
                                        c"GPUShaderStage",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();




            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
init_sConstants_specs::<D>();
init_sConstants_prefs::<D>();
        }
        } // mod GPUShaderStage_Binding


pub use self::GPUSupportedFeatures_Binding::{Wrap as GPUSupportedFeaturesWrap, GPUSupportedFeaturesMethods, GetProtoObject as GPUSupportedFeaturesGetProtoObject, DefineDOMInterface as GPUSupportedFeaturesDefineDOMInterface};
pub mod GPUSupportedFeatures_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_size<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedFeatures);
        let result: u32 = this.Size();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static size_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_size_getterinfo<D: DomTypes>() {
    size_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_size::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedFeatures as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn entries<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedFeatures);
        let args = &*args;
        let argc = args.argc_;
        let realm = AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()));
        let result = crate::iterable::IterableIterator::new(this, IteratorType::Entries, InRealm::already(&realm));


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

const entries_methodinfo_argTypes: [i32; 1] = [ JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
static entries_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_entries_methodinfo<D: DomTypes>() {
    entries_methodinfo.set(JSTypedMethodJitInfo {
        base:   JSJitInfo {
      __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
          method: Some(entries::<D>)
      },
      __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
          protoID: PrototypeList::ID::GPUSupportedFeatures as u16,
      },
      __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
      _bitfield_align_1: [],
      _bitfield_1: __BindgenBitfieldUnit::new(
          new_jsjitinfo_bitfield_1!(
              JSJitInfo_OpType::Method as u8,
              JSJitInfo_AliasSet::AliasEverything as u8,
              JSValueType::JSVAL_TYPE_OBJECT as u8,
              false,
              false,
              false,
              false,
              false,
              true,
              0,
          ).to_ne_bytes()
      ),
  },
        argTypes: &entries_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
    });
}

unsafe extern "C" fn keys<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedFeatures);
        let args = &*args;
        let argc = args.argc_;
        let realm = AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()));
        let result = crate::iterable::IterableIterator::new(this, IteratorType::Keys, InRealm::already(&realm));


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

const keys_methodinfo_argTypes: [i32; 1] = [ JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
static keys_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_keys_methodinfo<D: DomTypes>() {
    keys_methodinfo.set(JSTypedMethodJitInfo {
        base:   JSJitInfo {
      __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
          method: Some(keys::<D>)
      },
      __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
          protoID: PrototypeList::ID::GPUSupportedFeatures as u16,
      },
      __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
      _bitfield_align_1: [],
      _bitfield_1: __BindgenBitfieldUnit::new(
          new_jsjitinfo_bitfield_1!(
              JSJitInfo_OpType::Method as u8,
              JSJitInfo_AliasSet::AliasEverything as u8,
              JSValueType::JSVAL_TYPE_OBJECT as u8,
              false,
              false,
              false,
              false,
              false,
              true,
              0,
          ).to_ne_bytes()
      ),
  },
        argTypes: &keys_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
    });
}

unsafe extern "C" fn values<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedFeatures);
        let args = &*args;
        let argc = args.argc_;
        let realm = AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()));
        let result = crate::iterable::IterableIterator::new(this, IteratorType::Values, InRealm::already(&realm));


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

const values_methodinfo_argTypes: [i32; 1] = [ JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
static values_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_values_methodinfo<D: DomTypes>() {
    values_methodinfo.set(JSTypedMethodJitInfo {
        base:   JSJitInfo {
      __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
          method: Some(values::<D>)
      },
      __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
          protoID: PrototypeList::ID::GPUSupportedFeatures as u16,
      },
      __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
      _bitfield_align_1: [],
      _bitfield_1: __BindgenBitfieldUnit::new(
          new_jsjitinfo_bitfield_1!(
              JSJitInfo_OpType::Method as u8,
              JSJitInfo_AliasSet::AliasEverything as u8,
              JSValueType::JSVAL_TYPE_OBJECT as u8,
              false,
              false,
              false,
              false,
              false,
              true,
              0,
          ).to_ne_bytes()
      ),
  },
        argTypes: &values_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
    });
}

unsafe extern "C" fn forEach<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedFeatures);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUSupportedFeatures.forEach\".");
            return false;
        }
        let arg0: *mut JSObject = if HandleValue::from_raw(args.get(0)).get().is_object() {
            HandleValue::from_raw(args.get(0)).get().to_object()
        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: HandleValue = if args.get(1).is_undefined() {
            HandleValue::undefined()
        } else {
            HandleValue::from_raw(args.get(1))
        };
        if !IsCallable(arg0) {
          throw_type_error(cx.raw_cx(), "Argument 1 of GPUSupportedFeatures.forEach is not callable.");
          return false;
        }
        rooted!(&in(cx) let arg0 = ObjectValue(arg0));
        rooted!(&in(cx) let mut call_arg1 = UndefinedValue());
        rooted!(&in(cx) let mut call_arg2 = UndefinedValue());
        rooted_vec!(let mut call_args);
        call_args.push(UndefinedValue());
        call_args.push(UndefinedValue());
        call_args.push(ObjectValue(*_obj));
        rooted!(&in(cx) let mut ignoredReturnVal = UndefinedValue());

        // This has to be a while loop since get_iterable_length() may change during
        // the callback, and we need to avoid iterator invalidation.
        //
        // It is possible for this to loop infinitely, but that matches the spec
        // and other browsers.
        //
        // https://heycam.github.io/webidl/#es-forEach
        let mut i = 0;
        while i < (*this).get_iterable_length() {
          (*this).get_value_at_index(i).to_jsval(cx.raw_cx(), call_arg1.handle_mut());
          (*this).get_key_at_index(i).to_jsval(cx.raw_cx(), call_arg2.handle_mut());
          call_args[0] = call_arg1.handle().get();
          call_args[1] = call_arg2.handle().get();
          let call_args_handle = HandleValueArray::from(&call_args);
          if !Call(cx.raw_cx(), arg1, arg0.handle(), &call_args_handle,
                   ignoredReturnVal.handle_mut()) {
            return false;
          }

          i += 1;
        }

        let result = ();


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static forEach_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_forEach_methodinfo<D: DomTypes>() {
    forEach_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(forEach::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedFeatures as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn has<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedFeatures);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUSupportedFeatures.has\".");
            return false;
        }
        let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result = Setlike::has(this, arg0);


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

const has_methodinfo_argTypes: [i32; 2] = [ JSJitInfo_ArgType::String as i32, JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
static has_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_has_methodinfo<D: DomTypes>() {
    has_methodinfo.set(JSTypedMethodJitInfo {
        base:   JSJitInfo {
      __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
          method: Some(has::<D>)
      },
      __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
          protoID: PrototypeList::ID::GPUSupportedFeatures as u16,
      },
      __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
      _bitfield_align_1: [],
      _bitfield_1: __BindgenBitfieldUnit::new(
          new_jsjitinfo_bitfield_1!(
              JSJitInfo_OpType::Method as u8,
              JSJitInfo_AliasSet::AliasDOMSets as u8,
              JSValueType::JSVAL_TYPE_BOOLEAN as u8,
              false,
              false,
              false,
              false,
              false,
              true,
              0,
          ).to_ne_bytes()
      ),
  },
        argTypes: &has_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
    });
}

unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUSupportedFeatures>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUSupportedFeatures>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUSupportedFeatures".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUSupportedFeatures, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUSupportedFeatures> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUSupportedFeatures>, _can_gc: CanGc) -> DomRoot<D::GPUSupportedFeatures>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUSupportedFeaturesMethods<D: DomTypes> {
    fn Size(&self, ) -> u32;
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"entries".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { entries_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"keys".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { keys_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"values".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { values_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"forEach".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { forEach_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"has".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { has_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"size".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { size_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUSupportedFeatures".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUSupportedFeatures), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUSupportedFeaturesPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUSupportedFeatures() {\n    [native code]\n}",
        PrototypeList::ID::GPUSupportedFeatures,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUSupportedFeatures),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUSupportedFeatures as usize].is_null());
    (*cache)[PrototypeList::ID::GPUSupportedFeatures as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUSupportedFeatures as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUSupportedFeatures",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
    // Set up aliases on the interface prototype object we just created.

    rooted!(&in(cx) let mut aliasedVal = UndefinedValue());

    assert!(JS_GetProperty(cx.raw_cx(), prototype.handle(),
                           c"values".as_ptr() as *const u8 as *const _,
                           aliasedVal.handle_mut()));
    rooted!(&in(cx) let mut iteratorId: jsid);
    RUST_SYMBOL_TO_JSID(GetWellKnownSymbol(cx.raw_cx(), SymbolCode::iterator),                                   iteratorId.handle_mut());

    assert!(JS_DefinePropertyById2(cx.raw_cx(), prototype.handle(), iteratorId.handle(), aliasedVal.handle(), 0));

}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUSupportedFeatures_Binding::init_entries_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUSupportedFeatures_Binding::init_keys_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUSupportedFeatures_Binding::init_values_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUSupportedFeatures_Binding::init_forEach_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUSupportedFeatures_Binding::init_has_methodinfo::<D>();
            init_size_getterinfo::<D>();


            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUSupportedFeatures_Binding


pub use self::GPUSupportedLimits_Binding::{Wrap as GPUSupportedLimitsWrap, GPUSupportedLimitsMethods, GetProtoObject as GPUSupportedLimitsGetProtoObject, DefineDOMInterface as GPUSupportedLimitsDefineDOMInterface};
pub mod GPUSupportedLimits_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_maxTextureDimension1D<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxTextureDimension1D();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxTextureDimension1D_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxTextureDimension1D_getterinfo<D: DomTypes>() {
    maxTextureDimension1D_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxTextureDimension1D::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxTextureDimension2D<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxTextureDimension2D();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxTextureDimension2D_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxTextureDimension2D_getterinfo<D: DomTypes>() {
    maxTextureDimension2D_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxTextureDimension2D::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxTextureDimension3D<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxTextureDimension3D();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxTextureDimension3D_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxTextureDimension3D_getterinfo<D: DomTypes>() {
    maxTextureDimension3D_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxTextureDimension3D::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxTextureArrayLayers<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxTextureArrayLayers();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxTextureArrayLayers_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxTextureArrayLayers_getterinfo<D: DomTypes>() {
    maxTextureArrayLayers_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxTextureArrayLayers::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxBindGroups<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxBindGroups();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxBindGroups_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxBindGroups_getterinfo<D: DomTypes>() {
    maxBindGroups_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxBindGroups::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxBindGroupsPlusVertexBuffers<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxBindGroupsPlusVertexBuffers();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxBindGroupsPlusVertexBuffers_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxBindGroupsPlusVertexBuffers_getterinfo<D: DomTypes>() {
    maxBindGroupsPlusVertexBuffers_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxBindGroupsPlusVertexBuffers::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxBindingsPerBindGroup<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxBindingsPerBindGroup();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxBindingsPerBindGroup_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxBindingsPerBindGroup_getterinfo<D: DomTypes>() {
    maxBindingsPerBindGroup_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxBindingsPerBindGroup::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxDynamicUniformBuffersPerPipelineLayout<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxDynamicUniformBuffersPerPipelineLayout();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxDynamicUniformBuffersPerPipelineLayout_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxDynamicUniformBuffersPerPipelineLayout_getterinfo<D: DomTypes>() {
    maxDynamicUniformBuffersPerPipelineLayout_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxDynamicUniformBuffersPerPipelineLayout::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxDynamicStorageBuffersPerPipelineLayout<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxDynamicStorageBuffersPerPipelineLayout();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxDynamicStorageBuffersPerPipelineLayout_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxDynamicStorageBuffersPerPipelineLayout_getterinfo<D: DomTypes>() {
    maxDynamicStorageBuffersPerPipelineLayout_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxDynamicStorageBuffersPerPipelineLayout::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxSampledTexturesPerShaderStage<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxSampledTexturesPerShaderStage();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxSampledTexturesPerShaderStage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxSampledTexturesPerShaderStage_getterinfo<D: DomTypes>() {
    maxSampledTexturesPerShaderStage_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxSampledTexturesPerShaderStage::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxSamplersPerShaderStage<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxSamplersPerShaderStage();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxSamplersPerShaderStage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxSamplersPerShaderStage_getterinfo<D: DomTypes>() {
    maxSamplersPerShaderStage_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxSamplersPerShaderStage::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxStorageBuffersPerShaderStage<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxStorageBuffersPerShaderStage();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxStorageBuffersPerShaderStage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxStorageBuffersPerShaderStage_getterinfo<D: DomTypes>() {
    maxStorageBuffersPerShaderStage_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxStorageBuffersPerShaderStage::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxStorageTexturesPerShaderStage<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxStorageTexturesPerShaderStage();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxStorageTexturesPerShaderStage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxStorageTexturesPerShaderStage_getterinfo<D: DomTypes>() {
    maxStorageTexturesPerShaderStage_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxStorageTexturesPerShaderStage::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxUniformBuffersPerShaderStage<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxUniformBuffersPerShaderStage();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxUniformBuffersPerShaderStage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxUniformBuffersPerShaderStage_getterinfo<D: DomTypes>() {
    maxUniformBuffersPerShaderStage_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxUniformBuffersPerShaderStage::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxUniformBufferBindingSize<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u64 = this.MaxUniformBufferBindingSize();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxUniformBufferBindingSize_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxUniformBufferBindingSize_getterinfo<D: DomTypes>() {
    maxUniformBufferBindingSize_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxUniformBufferBindingSize::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxStorageBufferBindingSize<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u64 = this.MaxStorageBufferBindingSize();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxStorageBufferBindingSize_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxStorageBufferBindingSize_getterinfo<D: DomTypes>() {
    maxStorageBufferBindingSize_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxStorageBufferBindingSize::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_minUniformBufferOffsetAlignment<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MinUniformBufferOffsetAlignment();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static minUniformBufferOffsetAlignment_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_minUniformBufferOffsetAlignment_getterinfo<D: DomTypes>() {
    minUniformBufferOffsetAlignment_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_minUniformBufferOffsetAlignment::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_minStorageBufferOffsetAlignment<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MinStorageBufferOffsetAlignment();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static minStorageBufferOffsetAlignment_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_minStorageBufferOffsetAlignment_getterinfo<D: DomTypes>() {
    minStorageBufferOffsetAlignment_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_minStorageBufferOffsetAlignment::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxVertexBuffers<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxVertexBuffers();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxVertexBuffers_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxVertexBuffers_getterinfo<D: DomTypes>() {
    maxVertexBuffers_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxVertexBuffers::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxBufferSize<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u64 = this.MaxBufferSize();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxBufferSize_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxBufferSize_getterinfo<D: DomTypes>() {
    maxBufferSize_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxBufferSize::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxVertexAttributes<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxVertexAttributes();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxVertexAttributes_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxVertexAttributes_getterinfo<D: DomTypes>() {
    maxVertexAttributes_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxVertexAttributes::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxVertexBufferArrayStride<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxVertexBufferArrayStride();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxVertexBufferArrayStride_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxVertexBufferArrayStride_getterinfo<D: DomTypes>() {
    maxVertexBufferArrayStride_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxVertexBufferArrayStride::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxInterStageShaderComponents<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxInterStageShaderComponents();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxInterStageShaderComponents_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxInterStageShaderComponents_getterinfo<D: DomTypes>() {
    maxInterStageShaderComponents_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxInterStageShaderComponents::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxInterStageShaderVariables<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxInterStageShaderVariables();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxInterStageShaderVariables_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxInterStageShaderVariables_getterinfo<D: DomTypes>() {
    maxInterStageShaderVariables_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxInterStageShaderVariables::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxColorAttachments<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxColorAttachments();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxColorAttachments_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxColorAttachments_getterinfo<D: DomTypes>() {
    maxColorAttachments_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxColorAttachments::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxColorAttachmentBytesPerSample<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxColorAttachmentBytesPerSample();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxColorAttachmentBytesPerSample_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxColorAttachmentBytesPerSample_getterinfo<D: DomTypes>() {
    maxColorAttachmentBytesPerSample_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxColorAttachmentBytesPerSample::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxComputeWorkgroupStorageSize<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxComputeWorkgroupStorageSize();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxComputeWorkgroupStorageSize_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxComputeWorkgroupStorageSize_getterinfo<D: DomTypes>() {
    maxComputeWorkgroupStorageSize_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxComputeWorkgroupStorageSize::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxComputeInvocationsPerWorkgroup<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxComputeInvocationsPerWorkgroup();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxComputeInvocationsPerWorkgroup_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxComputeInvocationsPerWorkgroup_getterinfo<D: DomTypes>() {
    maxComputeInvocationsPerWorkgroup_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxComputeInvocationsPerWorkgroup::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxComputeWorkgroupSizeX<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxComputeWorkgroupSizeX();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxComputeWorkgroupSizeX_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxComputeWorkgroupSizeX_getterinfo<D: DomTypes>() {
    maxComputeWorkgroupSizeX_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxComputeWorkgroupSizeX::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxComputeWorkgroupSizeY<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxComputeWorkgroupSizeY();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxComputeWorkgroupSizeY_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxComputeWorkgroupSizeY_getterinfo<D: DomTypes>() {
    maxComputeWorkgroupSizeY_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxComputeWorkgroupSizeY::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxComputeWorkgroupSizeZ<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxComputeWorkgroupSizeZ();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxComputeWorkgroupSizeZ_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxComputeWorkgroupSizeZ_getterinfo<D: DomTypes>() {
    maxComputeWorkgroupSizeZ_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxComputeWorkgroupSizeZ::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_maxComputeWorkgroupsPerDimension<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUSupportedLimits);
        let result: u32 = this.MaxComputeWorkgroupsPerDimension();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static maxComputeWorkgroupsPerDimension_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_maxComputeWorkgroupsPerDimension_getterinfo<D: DomTypes>() {
    maxComputeWorkgroupsPerDimension_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_maxComputeWorkgroupsPerDimension::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedLimits as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUSupportedLimits>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUSupportedLimits>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUSupportedLimits".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUSupportedLimits, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUSupportedLimits> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUSupportedLimits>, _can_gc: CanGc) -> DomRoot<D::GPUSupportedLimits>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUSupportedLimitsMethods<D: DomTypes> {
    fn MaxTextureDimension1D(&self, ) -> u32;
    fn MaxTextureDimension2D(&self, ) -> u32;
    fn MaxTextureDimension3D(&self, ) -> u32;
    fn MaxTextureArrayLayers(&self, ) -> u32;
    fn MaxBindGroups(&self, ) -> u32;
    fn MaxBindGroupsPlusVertexBuffers(&self, ) -> u32;
    fn MaxBindingsPerBindGroup(&self, ) -> u32;
    fn MaxDynamicUniformBuffersPerPipelineLayout(&self, ) -> u32;
    fn MaxDynamicStorageBuffersPerPipelineLayout(&self, ) -> u32;
    fn MaxSampledTexturesPerShaderStage(&self, ) -> u32;
    fn MaxSamplersPerShaderStage(&self, ) -> u32;
    fn MaxStorageBuffersPerShaderStage(&self, ) -> u32;
    fn MaxStorageTexturesPerShaderStage(&self, ) -> u32;
    fn MaxUniformBuffersPerShaderStage(&self, ) -> u32;
    fn MaxUniformBufferBindingSize(&self, ) -> u64;
    fn MaxStorageBufferBindingSize(&self, ) -> u64;
    fn MinUniformBufferOffsetAlignment(&self, ) -> u32;
    fn MinStorageBufferOffsetAlignment(&self, ) -> u32;
    fn MaxVertexBuffers(&self, ) -> u32;
    fn MaxBufferSize(&self, ) -> u64;
    fn MaxVertexAttributes(&self, ) -> u32;
    fn MaxVertexBufferArrayStride(&self, ) -> u32;
    fn MaxInterStageShaderComponents(&self, ) -> u32;
    fn MaxInterStageShaderVariables(&self, ) -> u32;
    fn MaxColorAttachments(&self, ) -> u32;
    fn MaxColorAttachmentBytesPerSample(&self, ) -> u32;
    fn MaxComputeWorkgroupStorageSize(&self, ) -> u32;
    fn MaxComputeInvocationsPerWorkgroup(&self, ) -> u32;
    fn MaxComputeWorkgroupSizeX(&self, ) -> u32;
    fn MaxComputeWorkgroupSizeY(&self, ) -> u32;
    fn MaxComputeWorkgroupSizeZ(&self, ) -> u32;
    fn MaxComputeWorkgroupsPerDimension(&self, ) -> u32;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxTextureDimension1D".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxTextureDimension1D_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxTextureDimension2D".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxTextureDimension2D_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxTextureDimension3D".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxTextureDimension3D_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxTextureArrayLayers".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxTextureArrayLayers_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxBindGroups".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxBindGroups_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxBindGroupsPlusVertexBuffers".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxBindGroupsPlusVertexBuffers_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxBindingsPerBindGroup".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxBindingsPerBindGroup_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxDynamicUniformBuffersPerPipelineLayout".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxDynamicUniformBuffersPerPipelineLayout_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxDynamicStorageBuffersPerPipelineLayout".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxDynamicStorageBuffersPerPipelineLayout_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxSampledTexturesPerShaderStage".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxSampledTexturesPerShaderStage_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxSamplersPerShaderStage".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxSamplersPerShaderStage_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxStorageBuffersPerShaderStage".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxStorageBuffersPerShaderStage_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxStorageTexturesPerShaderStage".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxStorageTexturesPerShaderStage_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxUniformBuffersPerShaderStage".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxUniformBuffersPerShaderStage_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxUniformBufferBindingSize".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxUniformBufferBindingSize_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxStorageBufferBindingSize".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxStorageBufferBindingSize_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"minUniformBufferOffsetAlignment".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { minUniformBufferOffsetAlignment_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"minStorageBufferOffsetAlignment".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { minStorageBufferOffsetAlignment_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxVertexBuffers".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxVertexBuffers_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxBufferSize".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxBufferSize_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxVertexAttributes".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxVertexAttributes_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxVertexBufferArrayStride".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxVertexBufferArrayStride_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxInterStageShaderComponents".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxInterStageShaderComponents_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxInterStageShaderVariables".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxInterStageShaderVariables_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxColorAttachments".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxColorAttachments_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxColorAttachmentBytesPerSample".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxColorAttachmentBytesPerSample_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxComputeWorkgroupStorageSize".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxComputeWorkgroupStorageSize_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxComputeInvocationsPerWorkgroup".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxComputeInvocationsPerWorkgroup_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxComputeWorkgroupSizeX".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxComputeWorkgroupSizeX_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxComputeWorkgroupSizeY".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxComputeWorkgroupSizeY_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxComputeWorkgroupSizeZ".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxComputeWorkgroupSizeZ_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"maxComputeWorkgroupsPerDimension".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { maxComputeWorkgroupsPerDimension_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUSupportedLimits".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUSupportedLimits), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUSupportedLimitsPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUSupportedLimits() {\n    [native code]\n}",
        PrototypeList::ID::GPUSupportedLimits,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUSupportedLimits),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUSupportedLimits as usize].is_null());
    (*cache)[PrototypeList::ID::GPUSupportedLimits as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUSupportedLimits as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUSupportedLimits",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_maxTextureDimension1D_getterinfo::<D>();
init_maxTextureDimension2D_getterinfo::<D>();
init_maxTextureDimension3D_getterinfo::<D>();
init_maxTextureArrayLayers_getterinfo::<D>();
init_maxBindGroups_getterinfo::<D>();
init_maxBindGroupsPlusVertexBuffers_getterinfo::<D>();
init_maxBindingsPerBindGroup_getterinfo::<D>();
init_maxDynamicUniformBuffersPerPipelineLayout_getterinfo::<D>();
init_maxDynamicStorageBuffersPerPipelineLayout_getterinfo::<D>();
init_maxSampledTexturesPerShaderStage_getterinfo::<D>();
init_maxSamplersPerShaderStage_getterinfo::<D>();
init_maxStorageBuffersPerShaderStage_getterinfo::<D>();
init_maxStorageTexturesPerShaderStage_getterinfo::<D>();
init_maxUniformBuffersPerShaderStage_getterinfo::<D>();
init_maxUniformBufferBindingSize_getterinfo::<D>();
init_maxStorageBufferBindingSize_getterinfo::<D>();
init_minUniformBufferOffsetAlignment_getterinfo::<D>();
init_minStorageBufferOffsetAlignment_getterinfo::<D>();
init_maxVertexBuffers_getterinfo::<D>();
init_maxBufferSize_getterinfo::<D>();
init_maxVertexAttributes_getterinfo::<D>();
init_maxVertexBufferArrayStride_getterinfo::<D>();
init_maxInterStageShaderComponents_getterinfo::<D>();
init_maxInterStageShaderVariables_getterinfo::<D>();
init_maxColorAttachments_getterinfo::<D>();
init_maxColorAttachmentBytesPerSample_getterinfo::<D>();
init_maxComputeWorkgroupStorageSize_getterinfo::<D>();
init_maxComputeInvocationsPerWorkgroup_getterinfo::<D>();
init_maxComputeWorkgroupSizeX_getterinfo::<D>();
init_maxComputeWorkgroupSizeY_getterinfo::<D>();
init_maxComputeWorkgroupSizeZ_getterinfo::<D>();
init_maxComputeWorkgroupsPerDimension_getterinfo::<D>();


            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUSupportedLimits_Binding


pub use self::GPUTexture_Binding::{Wrap as GPUTextureWrap, GPUTextureMethods, GetProtoObject as GPUTextureGetProtoObject, DefineDOMInterface as GPUTextureDefineDOMInterface};
pub mod GPUTexture_Binding {
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureAspect;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureAspectValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureDimension;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureDimensionValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureFormat;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureFormatValues;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureViewDescriptor;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureViewDimension;
use crate::codegen::GenericBindings::WebGPUBinding::GPUTextureViewDimensionValues;
use crate::import::module::*;

unsafe extern "C" fn createView<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let args = &*args;
        let argc = args.argc_;
        let arg0: crate::codegen::GenericBindings::WebGPUBinding::GPUTextureViewDescriptor = if args.get(0).is_undefined() {
            crate::codegen::GenericBindings::WebGPUBinding::GPUTextureViewDescriptor::empty()
        } else {
            match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
                Ok(ConversionResult::Success(value)) => value,
                Ok(ConversionResult::Failure(error)) => {
                    throw_type_error(cx.raw_cx(), &error);
            return false;

                }
                _ => {
                    return false;

                },
            }

        };
        let result: Result<DomRoot<D::GPUTextureView>, Error> = this.CreateView(&arg0);
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static createView_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_createView_methodinfo<D: DomTypes>() {
    createView_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(createView::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn destroy<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let args = &*args;
        let argc = args.argc_;
        let result: () = this.Destroy();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static destroy_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_destroy_methodinfo<D: DomTypes>() {
    destroy_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(destroy::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_width<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let result: u32 = this.Width();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static width_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_width_getterinfo<D: DomTypes>() {
    width_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_width::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_height<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let result: u32 = this.Height();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static height_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_height_getterinfo<D: DomTypes>() {
    height_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_height::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_depthOrArrayLayers<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let result: u32 = this.DepthOrArrayLayers();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static depthOrArrayLayers_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_depthOrArrayLayers_getterinfo<D: DomTypes>() {
    depthOrArrayLayers_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_depthOrArrayLayers::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_mipLevelCount<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let result: u32 = this.MipLevelCount();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static mipLevelCount_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_mipLevelCount_getterinfo<D: DomTypes>() {
    mipLevelCount_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_mipLevelCount::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_sampleCount<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let result: u32 = this.SampleCount();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static sampleCount_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sampleCount_getterinfo<D: DomTypes>() {
    sampleCount_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_sampleCount::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_dimension<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let result: GPUTextureDimension = this.Dimension();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static dimension_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_dimension_getterinfo<D: DomTypes>() {
    dimension_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_dimension::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_format<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let result: GPUTextureFormat = this.Format();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static format_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_format_getterinfo<D: DomTypes>() {
    format_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_format::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_usage<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let result: u32 = this.Usage();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static usage_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_usage_getterinfo<D: DomTypes>() {
    usage_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_usage::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTexture);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTexture as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUTexture>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUTexture>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUTexture".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUTexture, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUTexture> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUTexture>, _can_gc: CanGc) -> DomRoot<D::GPUTexture>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUTextureMethods<D: DomTypes> {
    fn CreateView(&self, r#descriptor: &crate::codegen::GenericBindings::WebGPUBinding::GPUTextureViewDescriptor) -> Fallible<DomRoot<D::GPUTextureView>>;
    fn Destroy(&self, );
    fn Width(&self, ) -> u32;
    fn Height(&self, ) -> u32;
    fn DepthOrArrayLayers(&self, ) -> u32;
    fn MipLevelCount(&self, ) -> u32;
    fn SampleCount(&self, ) -> u32;
    fn Dimension(&self, ) -> GPUTextureDimension;
    fn Format(&self, ) -> GPUTextureFormat;
    fn Usage(&self, ) -> u32;
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"createView".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { createView_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"destroy".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { destroy_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"width".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { width_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"height".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { height_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"depthOrArrayLayers".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { depthOrArrayLayers_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"mipLevelCount".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { mipLevelCount_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"sampleCount".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { sampleCount_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"dimension".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { dimension_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"format".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { format_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"usage".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { usage_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUTexture".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUTexture), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUTexturePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUTexture() {\n    [native code]\n}",
        PrototypeList::ID::GPUTexture,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUTexture),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUTexture as usize].is_null());
    (*cache)[PrototypeList::ID::GPUTexture as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUTexture as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUTexture",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUTexture_Binding::init_createView_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::GPUTexture_Binding::init_destroy_methodinfo::<D>();
            init_width_getterinfo::<D>();
init_height_getterinfo::<D>();
init_depthOrArrayLayers_getterinfo::<D>();
init_mipLevelCount_getterinfo::<D>();
init_sampleCount_getterinfo::<D>();
init_dimension_getterinfo::<D>();
init_format_getterinfo::<D>();
init_usage_getterinfo::<D>();
init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUTexture_Binding


pub use self::GPUTextureUsage_Binding::{GPUTextureUsageConstants, Wrap as GPUTextureUsageWrap, GetProtoObject as GPUTextureUsageGetProtoObject, DefineDOMInterface as GPUTextureUsageDefineDOMInterface};
pub mod GPUTextureUsage_Binding {
use crate::import::module::*;

unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUTextureUsage>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUTextureUsage>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}

pub mod GPUTextureUsageConstants {
    pub const COPY_SRC: u32 = 1;
    pub const COPY_DST: u32 = 2;
    pub const TEXTURE_BINDING: u32 = 4;
    pub const STORAGE_BINDING: u32 = 8;
    pub const RENDER_ATTACHMENT: u32 = 16;
} // mod GPUTextureUsageConstants

static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUTextureUsage".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUTextureUsage, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUTextureUsage> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUTextureUsage>, _can_gc: CanGc) -> DomRoot<D::GPUTextureUsage>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUTextureUsageMethods<D: DomTypes> {
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUTextureUsage".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[0])])));
}static sConstants_specs: ThreadUnsafeOnceLock<&[&[ConstantSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_specs<D: DomTypes>() {
    sConstants_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    ConstantSpec { name: c"COPY_SRC", value: ConstantVal::Uint(1) },
    ConstantSpec { name: c"COPY_DST", value: ConstantVal::Uint(2) },
    ConstantSpec { name: c"TEXTURE_BINDING", value: ConstantVal::Uint(4) },
    ConstantSpec { name: c"STORAGE_BINDING", value: ConstantVal::Uint(8) },
    ConstantSpec { name: c"RENDER_ATTACHMENT", value: ConstantVal::Uint(16) }]))[..]
])));
}static sConstants: ThreadUnsafeOnceLock<&[Guard<&[ConstantSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sConstants_prefs<D: DomTypes>() {
    sConstants.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sConstants_specs.get() })[0])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUTextureUsage), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUTextureUsagePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUTextureUsage() {\n    [native code]\n}",
        PrototypeList::ID::GPUTextureUsage,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUTextureUsage),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      sConstants.get(),
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUTextureUsage as usize].is_null());
    (*cache)[PrototypeList::ID::GPUTextureUsage as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUTextureUsage as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        sConstants.get(),
                                        prototype.handle(),
                                        c"GPUTextureUsage",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();




            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
init_sConstants_specs::<D>();
init_sConstants_prefs::<D>();
        }
        } // mod GPUTextureUsage_Binding


pub use self::GPUTextureView_Binding::{Wrap as GPUTextureViewWrap, GPUTextureViewMethods, GetProtoObject as GPUTextureViewGetProtoObject, DefineDOMInterface as GPUTextureViewDefineDOMInterface};
pub mod GPUTextureView_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_label<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTextureView);
        let result: USVString = this.Label();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

unsafe extern "C" fn set_label<D: DomTypes>
(cx: *mut RawJSContext, obj: RawHandleObject, this: *mut libc::c_void, args: JSJitSetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUTextureView);
        let arg0: USVString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: () = this.SetLabel(arg0);

        true
    })());
    result
}


static label_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_getterinfo<D: DomTypes>() {
    label_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTextureView as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_STRING as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
static label_setterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_label_setterinfo<D: DomTypes>() {
    label_setterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        setter: Some(set_label::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUTextureView as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Setter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUTextureView>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUTextureView>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUTextureView".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUTextureView, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUTextureView> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUTextureView>, _can_gc: CanGc) -> DomRoot<D::GPUTextureView>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUTextureViewMethods<D: DomTypes> {
    fn Label(&self, ) -> USVString;
    fn SetLabel(&self, r#value: USVString);
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"label".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { label_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_setter), info: unsafe { label_setterinfo.get() } },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUTextureView".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUTextureView), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUTextureViewPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function GPUTextureView() {\n    [native code]\n}",
        PrototypeList::ID::GPUTextureView,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUTextureView),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUTextureView as usize].is_null());
    (*cache)[PrototypeList::ID::GPUTextureView as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUTextureView as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUTextureView",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_label_getterinfo::<D>();
            init_label_setterinfo::<D>();

            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUTextureView_Binding


pub use self::GPUUncapturedErrorEvent_Binding::{Wrap as GPUUncapturedErrorEventWrap, GPUUncapturedErrorEventMethods, GetProtoObject as GPUUncapturedErrorEventGetProtoObject, DefineDOMInterface as GPUUncapturedErrorEventDefineDOMInterface};
pub mod GPUUncapturedErrorEvent_Binding {
use crate::codegen::GenericBindings::EventBinding::Event_Binding;
use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
use crate::codegen::GenericBindings::WebGPUBinding::GPUUncapturedErrorEventInit;
use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
use crate::import::module::*;

unsafe extern "C" fn get_error<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUUncapturedErrorEvent);
        let result: DomRoot<D::GPUError> = this.Error();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static error_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_error_getterinfo<D: DomTypes>() {
    error_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_error::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUUncapturedErrorEvent as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn get_isTrusted<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::GPUUncapturedErrorEvent);
        let result: bool = this.IsTrusted();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static isTrusted_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_isTrusted_getterinfo<D: DomTypes>() {
    isTrusted_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_isTrusted::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUUncapturedErrorEvent as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 1 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_BOOLEAN as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUUncapturedErrorEvent>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUUncapturedErrorEvent>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUUncapturedErrorEvent".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::Event, PrototypeList::ID::GPUUncapturedErrorEvent, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 1,
    type_id: crate::codegen::InheritTypes::TopTypeId { event: (crate::codegen::InheritTypes::EventTypeId::GPUUncapturedErrorEvent) },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUUncapturedErrorEvent> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUUncapturedErrorEvent>, _can_gc: CanGc) -> DomRoot<D::GPUUncapturedErrorEvent>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());


    let mut slot = UndefinedValue();
    JS_GetReservedSlot(canonical_proto.get(), DOM_PROTO_UNFORGEABLE_HOLDER_SLOT, &mut slot);
    rooted!(&in(cx) let mut unforgeable_holder = ptr::null_mut::<JSObject>());
    unforgeable_holder.handle_mut().set(slot.to_object());
    assert!(JS_InitializePropertiesFromCompatibleNativeObject(cx.raw_cx(), obj.handle(), unforgeable_holder.handle()));


    DomRoot::from_ref(&*root)
}

pub trait GPUUncapturedErrorEventMethods<D: DomTypes> {
    fn Error(&self, ) -> DomRoot<D::GPUError>;
    fn IsTrusted(&self, ) -> bool;
    fn Constructor(r#global: &D::GlobalScope, r#proto: Option<HandleObject>, r#can_gc: CanGc, r#type_: DOMString, r#gpuUncapturedErrorEventInitDict: &crate::codegen::GenericBindings::WebGPUBinding::GPUUncapturedErrorEventInit<D>) -> DomRoot<D::GPUUncapturedErrorEvent>;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"error".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { error_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUUncapturedErrorEvent".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}static sLegacyUnforgeableAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sLegacyUnforgeableAttributes_specs<D: DomTypes>() {
    sLegacyUnforgeableAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"isTrusted".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE | JSPROP_PERMANENT),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { isTrusted_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sLegacyUnforgeableAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sLegacyUnforgeableAttributes_prefs<D: DomTypes>() {
    sLegacyUnforgeableAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::SERVICE_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::PAINT_WORKLET_GLOBAL_SCOPE),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE),Condition::Exposed(Globals::DEBUGGER_GLOBAL_SCOPE),Condition::Exposed(Globals::DISSIMILAR_ORIGIN_WINDOW),Condition::Exposed(Globals::TEST_WORKLET_GLOBAL_SCOPE)], (unsafe { sLegacyUnforgeableAttributes_specs.get() })[0])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUUncapturedErrorEvent), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUUncapturedErrorEventPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (1 & JSCLASS_RESERVED_SLOTS_MASK ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

unsafe extern "C" fn _constructor<D: DomTypes>
(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let args = CallArgs::from_vp(vp, argc);
        let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());

                    call_default_constructor::<D>(
                        SafeJSContext::from_ptr(cx.raw_cx()),
                        &args,
                        &global,
                        PrototypeList::ID::GPUUncapturedErrorEvent,
                        "GPUUncapturedErrorEvent",
                        CreateInterfaceObjects::<D>,
                        |cx: SafeJSContext, args: &CallArgs, global: &D::GlobalScope, desired_proto: HandleObject| {

        if argc < 2 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUUncapturedErrorEvent.constructor\".");
            return false;
        }
        let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let arg1: crate::codegen::GenericBindings::WebGPUBinding::GPUUncapturedErrorEventInit<D> = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(1)), ()) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: DomRoot<D::GPUUncapturedErrorEvent> = <D::GPUUncapturedErrorEvent>::Constructor(global, Some(desired_proto), CanGc::note(), arg0, &arg1);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
                        }
                    )

    });
    result
}


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
        b"function GPUUncapturedErrorEvent() {\n    [native code]\n}",
        PrototypeList::ID::GPUUncapturedErrorEvent,
        1,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUUncapturedErrorEvent),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    Event_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUUncapturedErrorEvent as usize].is_null());
    (*cache)[PrototypeList::ID::GPUUncapturedErrorEvent as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUUncapturedErrorEvent as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());

    Event_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUUncapturedErrorEvent",
                                        2,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());

    rooted!(&in(cx) let mut unforgeable_holder = ptr::null_mut::<JSObject>());
    unforgeable_holder.handle_mut().set(
        JS_NewObjectWithoutMetadata(cx.raw_cx(), &Class.get().base as *const JSClass, prototype.handle()));
    assert!(!unforgeable_holder.is_null());

    define_guarded_properties::<D>(cx, unforgeable_holder.handle(), unsafe { sLegacyUnforgeableAttributes.get() }, global);
    let val = ObjectValue(unforgeable_holder.get());
    JS_SetReservedSlot(prototype.get(), DOM_PROTO_UNFORGEABLE_HOLDER_SLOT, &val)
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();

            init_error_getterinfo::<D>();
init_isTrusted_getterinfo::<D>();


            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
init_sLegacyUnforgeableAttributes_specs::<D>();
init_sLegacyUnforgeableAttributes_prefs::<D>();
        }
        } // mod GPUUncapturedErrorEvent_Binding


pub use self::GPUValidationError_Binding::{Wrap as GPUValidationErrorWrap, GPUValidationErrorMethods, GetProtoObject as GPUValidationErrorGetProtoObject, DefineDOMInterface as GPUValidationErrorDefineDOMInterface};
pub mod GPUValidationError_Binding {
use crate::codegen::GenericBindings::EventTargetBinding::EventTarget_Binding;
use crate::codegen::GenericBindings::WebGPUBinding::GPUError_Binding;
use crate::codegen::GenericBindings::WorkerGlobalScopeBinding::WorkerGlobalScope_Binding;
use crate::import::module::*;

unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUValidationError>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::GPUValidationError>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUValidationError".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUError, PrototypeList::ID::GPUValidationError, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 1,
    type_id: crate::codegen::InheritTypes::TopTypeId { gpuerror: (crate::codegen::InheritTypes::GPUErrorTypeId::GPUValidationError) },
    malloc_size_of: malloc_size_of_including_raw_self::<D::GPUValidationError> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::GPUValidationError>, _can_gc: CanGc) -> DomRoot<D::GPUValidationError>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUValidationErrorMethods<D: DomTypes> {
    fn Constructor(r#global: &D::GlobalScope, r#proto: Option<HandleObject>, r#can_gc: CanGc, r#message: DOMString) -> DomRoot<D::GPUValidationError>;
}
static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUValidationError".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[0])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUValidationError), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUValidationErrorPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

unsafe extern "C" fn _constructor<D: DomTypes>
(cx: *mut RawJSContext, argc: u32, vp: *mut JSVal) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let args = CallArgs::from_vp(vp, argc);
        let global = D::GlobalScope::from_object(JS_CALLEE(cx.raw_cx(), vp).to_object());

                    call_default_constructor::<D>(
                        SafeJSContext::from_ptr(cx.raw_cx()),
                        &args,
                        &global,
                        PrototypeList::ID::GPUValidationError,
                        "GPUValidationError",
                        CreateInterfaceObjects::<D>,
                        |cx: SafeJSContext, args: &CallArgs, global: &D::GlobalScope, desired_proto: HandleObject| {

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"GPUValidationError.constructor\".");
            return false;
        }
        let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result: DomRoot<D::GPUValidationError> = <D::GPUValidationError>::Constructor(global, Some(desired_proto), CanGc::note(), arg0);

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
                        }
                    )

    });
    result
}


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::call(_constructor::<D>))),
        b"function GPUValidationError() {\n    [native code]\n}",
        PrototypeList::ID::GPUValidationError,
        1,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUValidationError),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::SERVICE_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    GPUError_Binding::GetProtoObject::<D>(cx, global, prototype_proto.handle_mut());
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      &[],
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUValidationError as usize].is_null());
    (*cache)[PrototypeList::ID::GPUValidationError as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUValidationError as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());

    GPUError_Binding::GetConstructorObject::<D>(cx, global, interface_proto.handle_mut());

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"GPUValidationError",
                                        1,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();




            init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUValidationError_Binding


pub use self::WGSLLanguageFeatures_Binding::{Wrap as WGSLLanguageFeaturesWrap, WGSLLanguageFeaturesMethods, GetProtoObject as WGSLLanguageFeaturesGetProtoObject, DefineDOMInterface as WGSLLanguageFeaturesDefineDOMInterface};
pub mod WGSLLanguageFeatures_Binding {
use crate::import::module::*;

unsafe extern "C" fn get_size<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: JSJitGetterCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::WGSLLanguageFeatures);
        let result: u32 = this.Size();

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static size_getterinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_size_getterinfo<D: DomTypes>() {
    size_getterinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        getter: Some(get_size::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::WGSLLanguageFeatures as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Getter as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_DOUBLE as u8,
            true,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn entries<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::WGSLLanguageFeatures);
        let args = &*args;
        let argc = args.argc_;
        let realm = AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()));
        let result = crate::iterable::IterableIterator::new(this, IteratorType::Entries, InRealm::already(&realm));


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

const entries_methodinfo_argTypes: [i32; 1] = [ JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
static entries_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_entries_methodinfo<D: DomTypes>() {
    entries_methodinfo.set(JSTypedMethodJitInfo {
        base:   JSJitInfo {
      __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
          method: Some(entries::<D>)
      },
      __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
          protoID: PrototypeList::ID::WGSLLanguageFeatures as u16,
      },
      __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
      _bitfield_align_1: [],
      _bitfield_1: __BindgenBitfieldUnit::new(
          new_jsjitinfo_bitfield_1!(
              JSJitInfo_OpType::Method as u8,
              JSJitInfo_AliasSet::AliasEverything as u8,
              JSValueType::JSVAL_TYPE_OBJECT as u8,
              false,
              false,
              false,
              false,
              false,
              true,
              0,
          ).to_ne_bytes()
      ),
  },
        argTypes: &entries_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
    });
}

unsafe extern "C" fn keys<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::WGSLLanguageFeatures);
        let args = &*args;
        let argc = args.argc_;
        let realm = AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()));
        let result = crate::iterable::IterableIterator::new(this, IteratorType::Keys, InRealm::already(&realm));


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

const keys_methodinfo_argTypes: [i32; 1] = [ JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
static keys_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_keys_methodinfo<D: DomTypes>() {
    keys_methodinfo.set(JSTypedMethodJitInfo {
        base:   JSJitInfo {
      __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
          method: Some(keys::<D>)
      },
      __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
          protoID: PrototypeList::ID::WGSLLanguageFeatures as u16,
      },
      __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
      _bitfield_align_1: [],
      _bitfield_1: __BindgenBitfieldUnit::new(
          new_jsjitinfo_bitfield_1!(
              JSJitInfo_OpType::Method as u8,
              JSJitInfo_AliasSet::AliasEverything as u8,
              JSValueType::JSVAL_TYPE_OBJECT as u8,
              false,
              false,
              false,
              false,
              false,
              true,
              0,
          ).to_ne_bytes()
      ),
  },
        argTypes: &keys_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
    });
}

unsafe extern "C" fn values<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::WGSLLanguageFeatures);
        let args = &*args;
        let argc = args.argc_;
        let realm = AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx()));
        let result = crate::iterable::IterableIterator::new(this, IteratorType::Values, InRealm::already(&realm));


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

const values_methodinfo_argTypes: [i32; 1] = [ JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
static values_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_values_methodinfo<D: DomTypes>() {
    values_methodinfo.set(JSTypedMethodJitInfo {
        base:   JSJitInfo {
      __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
          method: Some(values::<D>)
      },
      __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
          protoID: PrototypeList::ID::WGSLLanguageFeatures as u16,
      },
      __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
      _bitfield_align_1: [],
      _bitfield_1: __BindgenBitfieldUnit::new(
          new_jsjitinfo_bitfield_1!(
              JSJitInfo_OpType::Method as u8,
              JSJitInfo_AliasSet::AliasEverything as u8,
              JSValueType::JSVAL_TYPE_OBJECT as u8,
              false,
              false,
              false,
              false,
              false,
              true,
              0,
          ).to_ne_bytes()
      ),
  },
        argTypes: &values_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
    });
}

unsafe extern "C" fn forEach<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::WGSLLanguageFeatures);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"WGSLLanguageFeatures.forEach\".");
            return false;
        }
        let arg0: *mut JSObject = if HandleValue::from_raw(args.get(0)).get().is_object() {
            HandleValue::from_raw(args.get(0)).get().to_object()
        } else {
            throw_type_error(cx.raw_cx(), "Value is not an object.");
            return false;

        };
        let arg1: HandleValue = if args.get(1).is_undefined() {
            HandleValue::undefined()
        } else {
            HandleValue::from_raw(args.get(1))
        };
        if !IsCallable(arg0) {
          throw_type_error(cx.raw_cx(), "Argument 1 of WGSLLanguageFeatures.forEach is not callable.");
          return false;
        }
        rooted!(&in(cx) let arg0 = ObjectValue(arg0));
        rooted!(&in(cx) let mut call_arg1 = UndefinedValue());
        rooted!(&in(cx) let mut call_arg2 = UndefinedValue());
        rooted_vec!(let mut call_args);
        call_args.push(UndefinedValue());
        call_args.push(UndefinedValue());
        call_args.push(ObjectValue(*_obj));
        rooted!(&in(cx) let mut ignoredReturnVal = UndefinedValue());

        // This has to be a while loop since get_iterable_length() may change during
        // the callback, and we need to avoid iterator invalidation.
        //
        // It is possible for this to loop infinitely, but that matches the spec
        // and other browsers.
        //
        // https://heycam.github.io/webidl/#es-forEach
        let mut i = 0;
        while i < (*this).get_iterable_length() {
          (*this).get_value_at_index(i).to_jsval(cx.raw_cx(), call_arg1.handle_mut());
          (*this).get_key_at_index(i).to_jsval(cx.raw_cx(), call_arg2.handle_mut());
          call_args[0] = call_arg1.handle().get();
          call_args[1] = call_arg2.handle().get();
          let call_args_handle = HandleValueArray::from(&call_args);
          if !Call(cx.raw_cx(), arg1, arg0.handle(), &call_args_handle,
                   ignoredReturnVal.handle_mut()) {
            return false;
          }

          i += 1;
        }

        let result = ();


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static forEach_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_forEach_methodinfo<D: DomTypes>() {
    forEach_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(forEach::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::WGSLLanguageFeatures as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_UNDEFINED as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn has<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const D::WGSLLanguageFeatures);
        let args = &*args;
        let argc = args.argc_;

        if argc < 1 {
            throw_type_error(cx.raw_cx(), "Not enough arguments to \"WGSLLanguageFeatures.has\".");
            return false;
        }
        let arg0: DOMString = match FromJSValConvertible::from_jsval(cx.raw_cx(), HandleValue::from_raw(args.get(0)), StringificationBehavior::Default) {
            Ok(ConversionResult::Success(value)) => value,
            Ok(ConversionResult::Failure(error)) => {
                throw_type_error(cx.raw_cx(), &error);
        return false;

            }
            _ => {
                return false;

            },
        }
        ;
        let result = Setlike::has(this, arg0);


        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}

const has_methodinfo_argTypes: [i32; 2] = [ JSJitInfo_ArgType::String as i32, JSJitInfo_ArgType::ArgTypeListEnd as i32 ];
static has_methodinfo: ThreadUnsafeOnceLock<JSTypedMethodJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_has_methodinfo<D: DomTypes>() {
    has_methodinfo.set(JSTypedMethodJitInfo {
        base:   JSJitInfo {
      __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
          method: Some(has::<D>)
      },
      __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
          protoID: PrototypeList::ID::WGSLLanguageFeatures as u16,
      },
      __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
      _bitfield_align_1: [],
      _bitfield_1: __BindgenBitfieldUnit::new(
          new_jsjitinfo_bitfield_1!(
              JSJitInfo_OpType::Method as u8,
              JSJitInfo_AliasSet::AliasDOMSets as u8,
              JSValueType::JSVAL_TYPE_BOOLEAN as u8,
              false,
              false,
              false,
              false,
              false,
              true,
              0,
          ).to_ne_bytes()
      ),
  },
        argTypes: &has_methodinfo_argTypes as *const _ as *const JSJitInfo_ArgType,
    });
}

unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::WGSLLanguageFeatures>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<D::WGSLLanguageFeatures>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"WGSLLanguageFeatures".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::WGSLLanguageFeatures, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<D::WGSLLanguageFeatures> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<D::WGSLLanguageFeatures>, _can_gc: CanGc) -> DomRoot<D::WGSLLanguageFeatures>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait WGSLLanguageFeaturesMethods<D: DomTypes> {
    fn Size(&self, ) -> u32;
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"entries".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { entries_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"keys".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { keys_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"values".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { values_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"forEach".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { forEach_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"has".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { has_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 1,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { string_: c"size".as_ptr() },
                    attributes_: (JSPROP_ENUMERATE),
                    kind_: (JSPropertySpec_Kind::NativeAccessor),
                    u: JSPropertySpec_AccessorsOrValue {
                        accessors: JSPropertySpec_AccessorsOrValue_Accessors {
                            getter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: Some(generic_getter::<false>), info: unsafe { size_getterinfo.get() } },
                            },
                            setter: JSPropertySpec_Accessor {
                                native: JSNativeWrapper { op: None, info: ptr::null() },
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
,
&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"WGSLLanguageFeatures".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sAttributes_specs.get() })[0]),
    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[1])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::WGSLLanguageFeatures), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"WGSLLanguageFeaturesPrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};


static INTERFACE_OBJECT_CLASS: ThreadUnsafeOnceLock<NonCallbackInterfaceObjectClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_interface_object<D: DomTypes>() {
    INTERFACE_OBJECT_CLASS.set(NonCallbackInterfaceObjectClass::new(
        Box::leak(Box::new(InterfaceConstructorBehavior::throw())),
        b"function WGSLLanguageFeatures() {\n    [native code]\n}",
        PrototypeList::ID::WGSLLanguageFeatures,
        0,
    ));
}

pub fn DefineDOMInterface<D: DomTypes>
(cx: SafeJSContext, global: HandleObject){
    define_dom_interface(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::WGSLLanguageFeatures),CreateInterfaceObjects::<D>, ConstructorEnabled::<D>)
}

pub fn ConstructorEnabled<D: DomTypes>
(aCx: SafeJSContext, aObj: HandleObject) -> bool{
    is_exposed_in(aObj, Globals::DEDICATED_WORKER_GLOBAL_SCOPE | Globals::WINDOW) &&
    pref!(dom_webgpu_enabled)
}

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmObjectPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::WGSLLanguageFeatures as usize].is_null());
    (*cache)[PrototypeList::ID::WGSLLanguageFeatures as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::WGSLLanguageFeatures as isize),
                                  ptr::null_mut(),
                                  prototype.get());

    rooted!(&in(cx) let mut interface_proto = ptr::null_mut::<JSObject>());
    interface_proto.set(GetRealmFunctionPrototype(cx.raw_cx()));

    assert!(!interface_proto.is_null());

    rooted!(&in(cx) let mut interface = ptr::null_mut::<JSObject>());
    create_noncallback_interface_object::<D>(cx,
                                        global,
                                        interface_proto.handle(),
                                        INTERFACE_OBJECT_CLASS.get(),
                                        &[],
                                        &[],
                                        &[],
                                        prototype.handle(),
                                        c"WGSLLanguageFeatures",
                                        0,
                                        &[],
                                        interface.handle_mut());
    assert!(!interface.is_null());
    // Set up aliases on the interface prototype object we just created.

    rooted!(&in(cx) let mut aliasedVal = UndefinedValue());

    assert!(JS_GetProperty(cx.raw_cx(), prototype.handle(),
                           c"values".as_ptr() as *const u8 as *const _,
                           aliasedVal.handle_mut()));
    rooted!(&in(cx) let mut iteratorId: jsid);
    RUST_SYMBOL_TO_JSID(GetWellKnownSymbol(cx.raw_cx(), SymbolCode::iterator),                                   iteratorId.handle_mut());

    assert!(JS_DefinePropertyById2(cx.raw_cx(), prototype.handle(), iteratorId.handle(), aliasedVal.handle(), 0));

}


        pub(crate) fn init_statics<D: DomTypes>() {
            init_interface_object::<D>();
            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::WGSLLanguageFeatures_Binding::init_entries_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::WGSLLanguageFeatures_Binding::init_keys_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::WGSLLanguageFeatures_Binding::init_values_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::WGSLLanguageFeatures_Binding::init_forEach_methodinfo::<D>();
crate::codegen::GenericBindings::WebGPUBinding::WGSLLanguageFeatures_Binding::init_has_methodinfo::<D>();
            init_size_getterinfo::<D>();


            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod WGSLLanguageFeatures_Binding


pub use self::GPUSupportedFeaturesSetlike_Binding::{Wrap as GPUSupportedFeaturesSetlikeWrap, GPUSupportedFeaturesSetlikeMethods, GetProtoObject as GPUSupportedFeaturesSetlikeGetProtoObject};
pub mod GPUSupportedFeaturesSetlike_Binding {
use crate::import::module::*;

unsafe extern "C" fn next<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const crate::iterable::IterableIterator<D, D::GPUSupportedFeatures>);
        let args = &*args;
        let argc = args.argc_;
        let result: Result<NonNull<JSObject>, Error> = this.Next(SafeJSContext::from_ptr(cx.raw_cx()));
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static next_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_next_methodinfo<D: DomTypes>() {
    next_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(next::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::GPUSupportedFeaturesSetlike as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<crate::iterable::IterableIterator<D, D::GPUSupportedFeatures>>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<crate::iterable::IterableIterator<D, D::GPUSupportedFeatures>>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"GPUSupportedFeaturesSetlike".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::GPUSupportedFeaturesSetlike, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<crate::iterable::IterableIterator<D, D::GPUSupportedFeatures>> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<crate::iterable::IterableIterator<D, D::GPUSupportedFeatures>>, _can_gc: CanGc) -> DomRoot<crate::iterable::IterableIterator<D, D::GPUSupportedFeatures>>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait GPUSupportedFeaturesSetlikeMethods<D: DomTypes> {
    fn Next(&self, r#cx: SafeJSContext) -> Fallible<NonNull<JSObject>>;
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"next".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { next_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"GPUSupportedFeatures Setlike".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[0])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::GPUSupportedFeaturesSetlike), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"GPUSupportedFeaturesSetlikePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmIteratorPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::GPUSupportedFeaturesSetlike as usize].is_null());
    (*cache)[PrototypeList::ID::GPUSupportedFeaturesSetlike as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::GPUSupportedFeaturesSetlike as isize),
                                  ptr::null_mut(),
                                  prototype.get());

}


        pub(crate) fn init_statics<D: DomTypes>() {

            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::GPUSupportedFeaturesSetlike_Binding::init_next_methodinfo::<D>();



            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod GPUSupportedFeaturesSetlike_Binding


pub use self::WGSLLanguageFeaturesSetlike_Binding::{Wrap as WGSLLanguageFeaturesSetlikeWrap, WGSLLanguageFeaturesSetlikeMethods, GetProtoObject as WGSLLanguageFeaturesSetlikeGetProtoObject};
pub mod WGSLLanguageFeaturesSetlike_Binding {
use crate::import::module::*;

unsafe extern "C" fn next<D: DomTypes>
(cx: *mut RawJSContext, _obj: RawHandleObject, this: *mut libc::c_void, args: *const JSJitMethodCallArgs) -> bool{
    let mut result = false;
    wrap_panic(&mut || result = (|| {
        let mut cx = JSContext::from_ptr(ptr::NonNull::new(cx).unwrap());
        let this = &*(this as *const crate::iterable::IterableIterator<D, D::WGSLLanguageFeatures>);
        let args = &*args;
        let argc = args.argc_;
        let result: Result<NonNull<JSObject>, Error> = this.Next(SafeJSContext::from_ptr(cx.raw_cx()));
        let result = match result {
            Ok(result) => result,
            Err(e) => {
                <D as DomHelpers<D>>::throw_dom_exception(SafeJSContext::from_ptr(cx.raw_cx()), &this.global_(InRealm::already(&AlreadyInRealm::assert_for_cx(SafeJSContext::from_ptr(cx.raw_cx())))), e, CanGc::note());
                return false;
            },
        };

        (result).to_jsval(cx.raw_cx(), MutableHandleValue::from_raw(args.rval()));
        return true;
    })());
    result
}


static next_methodinfo: ThreadUnsafeOnceLock<JSJitInfo> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_next_methodinfo<D: DomTypes>() {
    next_methodinfo.set(JSJitInfo {
    __bindgen_anon_1: JSJitInfo__bindgen_ty_1 {
        method: Some(next::<D>)
    },
    __bindgen_anon_2: JSJitInfo__bindgen_ty_2 {
        protoID: PrototypeList::ID::WGSLLanguageFeaturesSetlike as u16,
    },
    __bindgen_anon_3: JSJitInfo__bindgen_ty_3 { depth: 0 },
    _bitfield_align_1: [],
    _bitfield_1: __BindgenBitfieldUnit::new(
        new_jsjitinfo_bitfield_1!(
            JSJitInfo_OpType::Method as u8,
            JSJitInfo_AliasSet::AliasEverything as u8,
            JSValueType::JSVAL_TYPE_OBJECT as u8,
            false,
            false,
            false,
            false,
            false,
            false,
            0,
        ).to_ne_bytes()
    ),
});
}
unsafe extern "C" fn _finalize<D: DomTypes>
(_cx: *mut GCContext, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<crate::iterable::IterableIterator<D, D::WGSLLanguageFeatures>>(obj).unwrap();
        finalize_common(this);
    })
}

unsafe extern "C" fn _trace<D: DomTypes>
(trc: *mut JSTracer, obj: *mut JSObject){
    wrap_panic(&mut || {

        let this = native_from_object_static::<crate::iterable::IterableIterator<D, D::WGSLLanguageFeatures>>(obj).unwrap();
        if this.is_null() { return; } // GC during obj creation
        (*this).trace(trc);
    })
}


static CLASS_OPS: ThreadUnsafeOnceLock<JSClassOps> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_class_ops<D: DomTypes>() {
    CLASS_OPS.set(JSClassOps {
        addProperty: None,
        delProperty: None,
        enumerate: None,
        newEnumerate: None,
        resolve: None,
        mayResolve: None,
        finalize: Some(_finalize::<D>),
        call: None,
        construct: None,
        trace: Some(_trace::<D>),
    });
}

pub static Class: ThreadUnsafeOnceLock<DOMJSClass> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_domjs_class<D: DomTypes>() {
    init_class_ops::<D>();
    Class.set(DOMJSClass {
        base: JSClass {
            name: c"WGSLLanguageFeaturesSetlike".as_ptr(),
            flags: JSCLASS_IS_DOMJSCLASS | JSCLASS_FOREGROUND_FINALIZE |
                   (((1) & JSCLASS_RESERVED_SLOTS_MASK) << JSCLASS_RESERVED_SLOTS_SHIFT)
                   /* JSCLASS_HAS_RESERVED_SLOTS(1) */,
            cOps: unsafe { CLASS_OPS.get() },
            spec: ptr::null(),
            ext: ptr::null(),
            oOps: ptr::null(),
        },
        dom_class:
DOMClass {
    interface_chain: [ PrototypeList::ID::WGSLLanguageFeaturesSetlike, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last, PrototypeList::ID::Last ],
    depth: 0,
    type_id: crate::codegen::InheritTypes::TopTypeId { alone: () },
    malloc_size_of: malloc_size_of_including_raw_self::<crate::iterable::IterableIterator<D, D::WGSLLanguageFeatures>> as unsafe fn(&mut _, _) -> _,
    global: Globals::EMPTY,
},
    });
}

#[cfg_attr(crown, allow(crown::unrooted_must_root))] pub unsafe fn Wrap<D: DomTypes>
(cx: SafeJSContext, scope: &D::GlobalScope, given_proto: Option<HandleObject>, object: Box<crate::iterable::IterableIterator<D, D::WGSLLanguageFeatures>>, _can_gc: CanGc) -> DomRoot<crate::iterable::IterableIterator<D, D::WGSLLanguageFeatures>>{

    let raw = Root::new(MaybeUnreflectedDom::from_box(object));

    let scope = scope.reflector().get_jsobject();
    assert!(!scope.get().is_null());
    assert!(((*get_object_class(scope.get())).flags & JSCLASS_IS_GLOBAL) != 0);
    let _ac = JSAutoRealm::new(cx.raw_cx(), scope.get());

    rooted!(&in(cx) let mut canonical_proto = ptr::null_mut::<JSObject>());
    GetProtoObject::<D>(cx, scope, canonical_proto.handle_mut());
    assert!(!canonical_proto.is_null());


    rooted!(&in(cx) let mut proto = ptr::null_mut::<JSObject>());
    if let Some(given) = given_proto {
        proto.set(*given);
        if get_context_realm(cx.raw_cx()) != get_object_realm(*given) {
            assert!(JS_WrapObject(cx.raw_cx(), proto.handle_mut()));
        }
    } else {
        proto.set(*canonical_proto);
    }
    rooted!(&in(cx) let obj = JS_NewObjectWithGivenProto(
        cx.raw_cx(),
        &Class.get().base,
        proto.handle(),
    ));
    assert!(!obj.is_null());
    JS_SetReservedSlot(
        obj.get(),
        DOM_OBJECT_SLOT,
        &PrivateValue(raw.as_ptr() as *const libc::c_void),
    );

    let root = raw.reflect_with(obj.get());



    DomRoot::from_ref(&*root)
}

pub trait WGSLLanguageFeaturesSetlikeMethods<D: DomTypes> {
    fn Next(&self, r#cx: SafeJSContext) -> Fallible<NonNull<JSObject>>;
}
static sMethods_specs: ThreadUnsafeOnceLock<&[&[JSFunctionSpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_specs<D: DomTypes>() {
    sMethods_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: c"next".as_ptr() },
        call: JSNativeWrapper { op: Some(generic_method::<false>), info: unsafe { next_methodinfo.get() } as *const _ as *const JSJitInfo },
        nargs: 0,
        flags: (JSPROP_ENUMERATE) as u16,
        selfHostedName: ptr::null()
    },
    JSFunctionSpec {
        name: JSPropertySpec_Name { string_: ptr::null() },
        call: JSNativeWrapper { op: None, info: ptr::null() },
        nargs: 0,
        flags: 0,
        selfHostedName: ptr::null()
    }]))[..]
])));
}static sMethods: ThreadUnsafeOnceLock<&[Guard<&[JSFunctionSpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sMethods_prefs<D: DomTypes>() {
    sMethods.set(Box::leak(Box::new([    Guard::new(&[Condition::Exposed(Globals::WINDOW),Condition::Exposed(Globals::DEDICATED_WORKER_GLOBAL_SCOPE)], (unsafe { sMethods_specs.get() })[0])])));
}static sAttributes_specs: ThreadUnsafeOnceLock<&[&[JSPropertySpec]]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_specs<D: DomTypes>() {
    sAttributes_specs.set(Box::leak(Box::new([&Box::leak(Box::new([
    JSPropertySpec {
                    name: JSPropertySpec_Name { symbol_: SymbolCode::toStringTag as usize + 1 },
                    attributes_: (JSPROP_READONLY),
                    kind_: (JSPropertySpec_Kind::Value),
                    u: JSPropertySpec_AccessorsOrValue {
                        value: JSPropertySpec_ValueWrapper {
                            type_: JSPropertySpec_ValueWrapper_Type::String,
                            __bindgen_anon_1: JSPropertySpec_ValueWrapper__bindgen_ty_1 {
                                string: c"WGSLLanguageFeatures Setlike".as_ptr(),
                            }
                        }
                    }
                }
,
    JSPropertySpec::ZERO]))[..]
])));
}static sAttributes: ThreadUnsafeOnceLock<&[Guard<&[JSPropertySpec]>]> = ThreadUnsafeOnceLock::new();

pub(crate) fn init_sAttributes_prefs<D: DomTypes>() {
    sAttributes.set(Box::leak(Box::new([    Guard::new(&[Condition::Satisfied], (unsafe { sAttributes_specs.get() })[0])])));
}
pub fn GetProtoObject<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, mut rval: MutableHandleObject){
    /* Get the interface prototype object for this class.  This will create the
       object as needed. */get_per_interface_object_handle(cx, global, ProtoOrIfaceIndex::ID(PrototypeList::ID::WGSLLanguageFeaturesSetlike), CreateInterfaceObjects::<D>, rval)
}


static PrototypeClass: JSClass = JSClass {
    name: c"WGSLLanguageFeaturesSetlikePrototype".as_ptr(),
    flags:
        // JSCLASS_HAS_RESERVED_SLOTS()
        (0 ) << JSCLASS_RESERVED_SLOTS_SHIFT,
    cOps: ptr::null(),
    spec: ptr::null(),
    ext: ptr::null(),
    oOps: ptr::null(),
};

unsafe fn CreateInterfaceObjects<D: DomTypes>
(cx: SafeJSContext, global: HandleObject, cache: *mut ProtoOrIfaceArray){

    rooted!(&in(cx) let mut prototype_proto = ptr::null_mut::<JSObject>());
    prototype_proto.set(GetRealmIteratorPrototype(cx.raw_cx()));
    assert!(!prototype_proto.is_null());

    rooted!(&in(cx) let mut prototype = ptr::null_mut::<JSObject>());
    create_interface_prototype_object::<D>(cx,
                                      global,
                                      prototype_proto.handle(),
                                      &PrototypeClass,
                                      sMethods.get(),
                                      sAttributes.get(),
                                      &[],
                                      &[],
                                      prototype.handle_mut());
    assert!(!prototype.is_null());
    assert!((*cache)[PrototypeList::ID::WGSLLanguageFeaturesSetlike as usize].is_null());
    (*cache)[PrototypeList::ID::WGSLLanguageFeaturesSetlike as usize] = prototype.get();
    <*mut JSObject>::post_barrier((*cache).as_mut_ptr().offset(PrototypeList::ID::WGSLLanguageFeaturesSetlike as isize),
                                  ptr::null_mut(),
                                  prototype.get());

}


        pub(crate) fn init_statics<D: DomTypes>() {

            init_domjs_class::<D>();
            crate::codegen::GenericBindings::WebGPUBinding::WGSLLanguageFeaturesSetlike_Binding::init_next_methodinfo::<D>();



            init_sMethods_specs::<D>();
init_sMethods_prefs::<D>();
init_sAttributes_specs::<D>();
init_sAttributes_prefs::<D>();
        }
        } // mod WGSLLanguageFeaturesSetlike_Binding